prefab-cloud-ruby 0.21.0 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a34b06515d401b7e73fd8b6adf77294187d94ea3a1d1909d159ebfd63b4046ad
-  data.tar.gz: 6ba449742b1a75517b35a47151452dbdf94c0a8aef0e58a639ae5b2481262d43
+  metadata.gz: f5df09f0991b0d46c29ce33bc010116733960a5004ede7dd5a0df868b15e4a29
+  data.tar.gz: ded97aa4f8e2dc37e7581ee5d29c7bcb3eff88e7aa8f72fedb7bd9710050bfec
 SHA512:
-  metadata.gz: 0a32e0ac965c54d634c579de66927d2982cca26d7098daaf3cdfd2dda88bf04bd33265c1e9f85e303d75fc9360f6df202cee256e59a91012b94f0adcf29252aa
-  data.tar.gz: 2c37b2cfeef43f44d2dcbe8835ff8ea130393ad98dd9dd61328371972bf1818ab12d932f6bec319a52ec2423f9204762c6305ab3643023a3aa5ea4bfd18974bf
+  metadata.gz: 5e44b86fabd88830aed86910f4ff9175df14a06dc30b19821c741c691a9637bcff69870de0d816c2348a650dc9eb5b3a3c54a4452f71039aaab2f042086c3536
+  data.tar.gz: d81cf8af71e9aa189e7ba8b7078af6472df4dc6e3b08a33771163363424986d8b194c0ed88fa961217758ee9e5d21ca5604810f96db53a80366d72df606cb6d7

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)
@@ -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.22.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,7 +34,7 @@ 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
@@ -55,9 +59,17 @@ 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 log_internal(level, msg, path = nil)
@@ -65,6 +77,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 +87,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)
@@ -99,7 +99,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 +119,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 +135,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 +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 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 +180,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 +201,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 +209,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 +223,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}"

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

data/lib/prefab_pb.rb

@@ -181,6 +181,24 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       optional :sequence_name, :string, 3
       optional :size, :int64, 4
     end
+    add_message "prefab.Loggers" do
+      repeated :loggers, :message, 1, "prefab.Logger"
+      optional :start_at, :int64, 2
+      optional :end_at, :int64, 3
+      optional :instance_hash, :string, 4
+      proto3_optional :namespace, :string, 5
+    end
+    add_message "prefab.Logger" do
+      optional :logger_name, :string, 1
+      proto3_optional :traces, :int64, 2
+      proto3_optional :debugs, :int64, 3
+      proto3_optional :infos, :int64, 4
+      proto3_optional :warns, :int64, 5
+      proto3_optional :errors, :int64, 6
+      proto3_optional :fatals, :int64, 7
+    end
+    add_message "prefab.LoggerReportResponse" do
+    end
     add_enum "prefab.ConfigType" do
       value :NOT_SET_CONFIG_TYPE, 0
       value :CONFIG, 1
@@ -236,6 +254,9 @@ module Prefab
   CreationResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.CreationResponse").msgclass
   IdBlock = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.IdBlock").msgclass
   IdBlockRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.IdBlockRequest").msgclass
+  Loggers = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.Loggers").msgclass
+  Logger = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.Logger").msgclass
+  LoggerReportResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.LoggerReportResponse").msgclass
   ConfigType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.ConfigType").enummodule
   LogLevel = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.LogLevel").enummodule
   OnFailure = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.OnFailure").enummodule

data/lib/prefab_services_pb.rb

@@ -61,6 +61,20 @@ module Prefab
       rpc :GetAll, ::Prefab::Identity, ::Prefab::ConfigEvaluations
     end
 
+    Stub = Service.rpc_stub_class
+  end
+  module LoggerReportingService
+    class Service
+
+      include ::GRPC::GenericService
+
+      self.marshal_class_method = :encode
+      self.unmarshal_class_method = :decode
+      self.service_name = 'prefab.LoggerReportingService'
+
+      rpc :Send, ::Prefab::Loggers, ::Prefab::LoggerReportResponse
+    end
+
     Stub = Service.rpc_stub_class
   end
 end

data/prefab-cloud-ruby.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: prefab-cloud-ruby 0.21.0 ruby lib
+# stub: prefab-cloud-ruby 0.22.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "prefab-cloud-ruby".freeze
-  s.version = "0.21.0"
+  s.version = "0.22.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Jeff Dwyer".freeze]
-  s.date = "2023-02-27"
+  s.date = "2023-03-15"
   s.description = "RateLimits & Config as a service".freeze
   s.email = "jdwyer@prefab.cloud".freeze
   s.extra_rdoc_files = [
@@ -48,6 +48,7 @@ Gem::Specification.new do |s|
     "lib/prefab/feature_flag_client.rb",
     "lib/prefab/internal_logger.rb",
     "lib/prefab/local_config_parser.rb",
+    "lib/prefab/log_path_collector.rb",
     "lib/prefab/logger_client.rb",
     "lib/prefab/murmer3.rb",
     "lib/prefab/noop_cache.rb",
@@ -74,7 +75,9 @@ Gem::Specification.new do |s|
     "test/test_helper.rb",
     "test/test_integration.rb",
     "test/test_local_config_parser.rb",
+    "test/test_log_path_collector.rb",
     "test/test_logger.rb",
+    "test/test_options.rb",
     "test/test_weighted_value_resolver.rb"
   ]
   s.homepage = "http://github.com/prefab-cloud/prefab-cloud-ruby".freeze
@@ -93,6 +96,7 @@ Gem::Specification.new do |s|
     s.add_runtime_dependency(%q<google-protobuf>.freeze, [">= 0"])
     s.add_runtime_dependency(%q<grpc>.freeze, [">= 0"])
     s.add_runtime_dependency(%q<ld-eventsource>.freeze, [">= 0"])
+    s.add_runtime_dependency(%q<uuid>.freeze, [">= 0"])
     s.add_development_dependency(%q<benchmark-ips>.freeze, [">= 0"])
     s.add_development_dependency(%q<bundler>.freeze, [">= 0"])
     s.add_development_dependency(%q<grpc-tools>.freeze, [">= 0"])
@@ -106,6 +110,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<google-protobuf>.freeze, [">= 0"])
     s.add_dependency(%q<grpc>.freeze, [">= 0"])
     s.add_dependency(%q<ld-eventsource>.freeze, [">= 0"])
+    s.add_dependency(%q<uuid>.freeze, [">= 0"])
     s.add_dependency(%q<benchmark-ips>.freeze, [">= 0"])
     s.add_dependency(%q<bundler>.freeze, [">= 0"])
     s.add_dependency(%q<grpc-tools>.freeze, [">= 0"])

data/test/test_client.rb

@@ -84,6 +84,30 @@ class TestClient < Minitest::Test
     assert certs.length > 1
   end
 
+  def test_initialization_with_an_options_object
+    options_hash = {
+      namespace: 'test-namespace',
+      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
+    }
+
+    options = Prefab::Options.new(options_hash)
+
+    client = Prefab::Client.new(options)
+
+    assert_equal client.namespace, 'test-namespace'
+  end
+
+  def test_initialization_with_a_hash
+    options_hash = {
+      namespace: 'test-namespace',
+      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
+    }
+
+    client = Prefab::Client.new(options_hash)
+
+    assert_equal client.namespace, 'test-namespace'
+  end
+
   private
 
   def new_client(overrides = {})

data/test/test_log_path_collector.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class TestLogPathCollector < Minitest::Test
+  def test_sync
+    Timecop.freeze do
+      client = new_client(namespace: 'this.is.a.namespace')
+
+      2.times { client.log.info('here is a message') }
+      3.times { client.log.error('here is a message') }
+
+      requests = []
+
+      client.define_singleton_method(:request) do |*params|
+        requests.push(params)
+      end
+
+      client.log_path_collector.send(:sync)
+
+      # let the flush thread run
+      sleep 0.01 while requests.length == 0
+
+      assert_equal requests, [[
+        Prefab::LoggerReportingService,
+        :send,
+        {
+          req_options: {},
+          params: Prefab::Loggers.new(
+            loggers: [Prefab::Logger.new(logger_name: 'test.test_log_path_collector.test_sync',
+                                         infos: 2, errors: 3)],
+            start_at: (Time.now.utc.to_f * 1000).to_i,
+            end_at: (Time.now.utc.to_f * 1000).to_i,
+            instance_hash: client.instance_hash,
+            namespace: 'this.is.a.namespace'
+          )
+        }
+      ]]
+    end
+  end
+
+  private
+
+  def new_client(overrides = {})
+    options = Prefab::Options.new(**{
+      prefab_config_override_dir: 'none',
+      prefab_config_classpath_dir: 'test',
+      prefab_envs: ['unit_tests'],
+      api_key: '123-development-yourapikey-SDK',
+      collect_sync_interval: 1000 # we'll trigger sync manually in our test
+    }.merge(overrides))
+
+    Prefab::Client.new(options)
+  end
+end

data/test/test_logger.rb

@@ -47,37 +47,37 @@ class TestCLogger < Minitest::Test
   def test_level_of
     with_env('PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL', 'info') do
       # env var overrides the default level
-      assert_equal Logger::INFO,
+      assert_equal ::Logger::INFO,
                    @logger.level_of('app.models.user'), 'PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL is info'
 
       @logger.set_config_client(MockConfigClient.new({}))
-      assert_equal Logger::WARN,
+      assert_equal ::Logger::WARN,
                    @logger.level_of('app.models.user'), 'default is warn'
 
       @logger.set_config_client(MockConfigClient.new('log-level.app' => :INFO))
-      assert_equal Logger::INFO,
+      assert_equal ::Logger::INFO,
                    @logger.level_of('app.models.user')
 
       @logger.set_config_client(MockConfigClient.new('log-level.app' => :DEBUG))
-      assert_equal Logger::DEBUG,
+      assert_equal ::Logger::DEBUG,
                    @logger.level_of('app.models.user')
 
       @logger.set_config_client(MockConfigClient.new('log-level.app' => :DEBUG,
                                                      'log-level.app.models' => :ERROR))
-      assert_equal Logger::ERROR,
+      assert_equal ::Logger::ERROR,
                    @logger.level_of('app.models.user'), 'test leveling'
     end
   end
 
   def test_log_internal
     logger, mock_logdev = mock_logger_expecting(/W, \[.*\]  WARN -- cloud.prefab.client.test.path: : test message/)
-    logger.log_internal('test message', 'test.path', '', Logger::WARN)
+    logger.log_internal('test message', 'test.path', '', ::Logger::WARN)
     mock_logdev.verify
   end
 
   def test_log_internal_unknown
     logger, mock_logdev = mock_logger_expecting(/A, \[.*\]   ANY -- cloud.prefab.client.test.path: : test message/)
-    logger.log_internal('test message', 'test.path', '', Logger::UNKNOWN)
+    logger.log_internal('test message', 'test.path', '', ::Logger::UNKNOWN)
     mock_logdev.verify
   end
 
@@ -85,30 +85,30 @@ class TestCLogger < Minitest::Test
     logger, mock_logdev = mock_logger_expecting(/W, \[.*\]  WARN -- cloud.prefab.client.test.path: : should log/,
                                                 calls: 2)
     logger.silence do
-      logger.log_internal('should not log', 'test.path', '', Logger::WARN)
+      logger.log_internal('should not log', 'test.path', '', ::Logger::WARN)
     end
-    logger.log_internal('should log', 'test.path', '', Logger::WARN)
+    logger.log_internal('should log', 'test.path', '', ::Logger::WARN)
     mock_logdev.verify
   end
 
   def test_log
     logger, mock_logdev = mock_logger_expecting(/W, \[.*\]  WARN -- test.path: : test message/)
-    logger.log('test message', 'test.path', '', Logger::WARN)
+    logger.log('test message', 'test.path', '', ::Logger::WARN)
     mock_logdev.verify
   end
 
   def test_log_unknown
     logger, mock_logdev = mock_logger_expecting(/A, \[.*\]   ANY -- test.path: : test message/)
-    logger.log('test message', 'test.path', '', Logger::UNKNOWN)
+    logger.log('test message', 'test.path', '', ::Logger::UNKNOWN)
     mock_logdev.verify
   end
 
   def test_log_silencing
     logger, mock_logdev = mock_logger_expecting(/W, \[.*\]  WARN -- test.path: : should log/, calls: 2)
     logger.silence do
-      logger.log('should not log', 'test.path', '', Logger::WARN)
+      logger.log('should not log', 'test.path', '', ::Logger::WARN)
     end
-    logger.log('should log', 'test.path', '', Logger::WARN)
+    logger.log('should log', 'test.path', '', ::Logger::WARN)
     mock_logdev.verify
   end
 

data/test/test_options.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestOptions < Minitest::Test
+  API_KEY = 'abcdefg'
+
+  def test_works_with_named_arguments
+    assert_equal API_KEY, Prefab::Options.new(api_key: API_KEY).api_key
+  end
+
+  def test_works_with_hash
+    assert_equal API_KEY, Prefab::Options.new({ api_key: API_KEY }).api_key
+  end
+
+  def test_collect_max_paths
+    assert_equal 1000, Prefab::Options.new.collect_max_paths
+    assert_equal 100, Prefab::Options.new(collect_max_paths: 100).collect_max_paths
+  end
+
+  def test_collect_max_paths_with_local_only
+    options = Prefab::Options.new(collect_max_paths: 100,
+                                  prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY)
+    assert_equal 0, options.collect_max_paths
+  end
+
+  def test_collect_max_paths_with_collect_logs_false
+    options = Prefab::Options.new(collect_max_paths: 100,
+                                  collect_logs: false)
+    assert_equal 0, options.collect_max_paths
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefab-cloud-ruby
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.22.0
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-27 00:00:00.000000000 Z
+date: 2023-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -100,6 +100,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: uuid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
@@ -221,6 +235,7 @@ files:
 - lib/prefab/feature_flag_client.rb
 - lib/prefab/internal_logger.rb
 - lib/prefab/local_config_parser.rb
+- lib/prefab/log_path_collector.rb
 - lib/prefab/logger_client.rb
 - lib/prefab/murmer3.rb
 - lib/prefab/noop_cache.rb
@@ -247,7 +262,9 @@ files:
 - test/test_helper.rb
 - test/test_integration.rb
 - test/test_local_config_parser.rb
+- test/test_log_path_collector.rb
 - test/test_logger.rb
+- test/test_options.rb
 - test/test_weighted_value_resolver.rb
 homepage: http://github.com/prefab-cloud/prefab-cloud-ruby
 licenses: