prefab-cloud-ruby 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e22f15bdc4f3f3d98d0a397e0685a7b457231cc
-  data.tar.gz: 3a1b5af166637f72160e1fdea3ed2f0d08aa2ded
+  metadata.gz: 70b7e6905adede604544ce942c02d4b77c8e368b
+  data.tar.gz: 9b5091d9df705f1c8dd01ab7bc218ac0bcdada04
 SHA512:
-  metadata.gz: a94a74cc16025df1c4cf0cdf2a1a8b1aa1f7b501bb9aba66d7643ba643ed96f82b840adabed2f14a3038a5f10aac4641557869777da0cf56d842dfcb1e3d9e06
-  data.tar.gz: 9c659f681aa37174f81967e8a698fbf796f87c4d12bc647353e5e30b0266b6e6f0a127ace4fe342bb4d55c97fdf83957559ad95ff750c4b81310e6cd3a6957e5
+  metadata.gz: 75fb25229c3523976b4048c4bbc220705486062620c8f51951ff41cb80c0b575cb4bbab1cf792366c108c553b94a00a0f89b594e328d725eeb7a58bce8990865
+  data.tar.gz: a8cc43a7a3e102bd4bfe131f93e3ff0eb0a389cc3e8ba10357d426aefd5608ebcee9269cc6ca228ae059ee0b8ec590e09fa7a68cb5f383c176254563df4e0817

data/VERSION

@@ -1 +1 @@
-0.0.13
+0.0.14

data/lib/prefab-cloud-ruby.rb

@@ -13,6 +13,5 @@ require 'prefab/logger_client'
 require 'prefab/auth_interceptor'
 require 'prefab/noop_cache'
 require 'prefab/noop_stats'
-require 'prefab/retry'
 require 'prefab/murmer3'
 

data/lib/prefab/client.rb

@@ -1,5 +1,9 @@
 module Prefab
   class Client
+
+    MAX_SLEEP_SEC = 10
+    BASE_SLEEP_SEC = 0.5
+
     attr_reader :account_id, :shared_cache, :stats, :namespace, :creds, :interceptor
 
     def initialize(api_key: ENV['PREFAB_API_KEY'],
@@ -21,8 +25,8 @@ module Prefab
       @namespace = namespace
 
       @interceptor = AuthInterceptor.new(api_key)
-
       @creds = GRPC::Core::ChannelCredentials.new(ssl_certs)
+      @stubs = {}
     end
 
     def channel
@@ -38,7 +42,7 @@ module Prefab
 
     def config_client(timeout: 5.0)
       @config_client ||= Prefab::ConfigClient.new(self, timeout)
-      @config_init = true
+      @config_client.init
       @config_client
     end
 
@@ -51,12 +55,53 @@ module Prefab
     end
 
     def log(base_logger = @logger)
-      return @logger if !@config_init
       @logger_client || Prefab::LoggerClient.new(self, base_logger)
     end
 
+    def log_internal(level, msg)
+      log.log_for level, msg, "prefab"
+    end
+
+    def request(service, method, req_options: {}, params: {})
+      opts = { timeout: 10 }.merge(req_options)
+
+      attempts = 0
+      start_time = Time.now
+
+      begin
+        attempts += 1
+        return stub_for(service).send(method, *params)
+      rescue => exception
+
+        log_internal :warn, exception
+
+        if Time.now - start_time > opts[:timeout]
+          raise exception
+        end
+        sleep_seconds = [BASE_SLEEP_SEC * (2 ** (attempts - 1)), MAX_SLEEP_SEC].min
+        sleep_seconds = sleep_seconds * (0.5 * (1 + rand()))
+        sleep_seconds = [BASE_SLEEP_SEC, sleep_seconds].max
+        log_internal :info, "Sleep #{sleep_seconds} and Reset #{service} #{method}"
+        sleep sleep_seconds
+        reset!
+        retry
+      end
+    end
+
     private
 
+    def reset!
+      @stubs.clear
+      reset_channel!
+    end
+
+    def stub_for(service)
+      @stubs[service] ||= service::Stub.new(nil,
+                                            nil,
+                                            channel_override: channel,
+                                            interceptors: [@interceptor])
+    end
+
     def ssl_certs
       ssl_certs = ""
       Dir["#{OpenSSL::X509::DEFAULT_CERT_DIR}/*.pem"].each do |cert|

data/lib/prefab/config_client.rb

@@ -7,16 +7,23 @@ module Prefab
     def initialize(base_client, timeout)
       @base_client = base_client
       @timeout = timeout
-      @config_loader = Prefab::ConfigLoader.new(base_client)
-      @config_resolver = Prefab::ConfigResolver.new(base_client, @config_loader)
-      start_at_id = load_checkpoint
-      start_api_connection_thread(start_at_id)
-      start_checkpointing_thread
-      start_suspenders_thread
+      @initialized = false
+    end
+
+    def init
+      if !@initialized
+        @initialized = true
+        @config_loader = Prefab::ConfigLoader.new(@base_client)
+        @config_resolver = Prefab::ConfigResolver.new(@base_client, @config_loader)
+        start_at_id = load_checkpoint
+        start_api_connection_thread(start_at_id)
+        start_checkpointing_thread
+        start_suspenders_thread
+      end
     end
 
     def get(prop)
-      @config_resolver.get(prop)
+      @config_resolver.get(prop) if @config_resolver
     end
 
     def upsert(key, config_value, namespace = nil, previous_key = nil)
@@ -26,7 +33,8 @@ module Prefab
       upsert_req = Prefab::UpsertRequest.new(config_delta: config_delta)
       upsert_req.previous_key = previous_key if previous_key&.present?
 
-      Retry.it method(:stub_with_timeout), :upsert, upsert_req, @timeout, method(:reset)
+      @base_client.request Prefab::ConfigService, :upsert, req_options: {timeout: @timeout}, params: upsert_req
+
       @config_loader.set(config_delta)
       @config_loader.rm(previous_key) if previous_key&.present?
       @config_resolver.update
@@ -35,7 +43,6 @@ module Prefab
     def reset
       @base_client.reset_channel!
       @_stub = nil
-      @_stub_with_timeout = nil
     end
 
     def to_s
@@ -56,14 +63,6 @@ module Prefab
                                                interceptors: [@base_client.interceptor])
     end
 
-    def stub_with_timeout
-      @_stub_with_timeout = Prefab::ConfigService::Stub.new(nil,
-                                                            nil,
-                                                            channel_override: @base_client.channel,
-                                                            timeout: @timeout,
-                                                            interceptors: [@base_client.interceptor])
-    end
-
     def cache_key
       "prefab:config:checkpoint"
     end
@@ -77,14 +76,14 @@ module Prefab
       if checkpoint
         deltas = Prefab::ConfigDeltas.decode(checkpoint)
         deltas.deltas.each do |delta|
-          @base_client.log.debug "checkpoint set #{delta.key} #{delta.value.int} #{delta.value.string} #{delta.id} "
+          @base_client.log_internal :debug, "checkpoint set #{delta.key} #{delta.value.int} #{delta.value.string} #{delta.id} "
           @config_loader.set(delta)
           start_at_id = [delta.id, start_at_id].max
         end
-        @base_client.log.info "Found checkpoint with highwater id #{start_at_id}"
+        @base_client.log_internal :info, "Found checkpoint with highwater id #{start_at_id}"
         @config_resolver.update
       else
-        @base_client.log.info "No checkpoint"
+        @base_client.log_internal :info, "No checkpoint"
       end
 
       start_at_id
@@ -101,10 +100,10 @@ module Prefab
               sleep(delta)
             end
             deltas = @config_resolver.export_api_deltas
-            @base_client.log.debug "==CHECKPOINT==#{deltas.deltas.map {|d| d.id}.max}===#{Thread.current.object_id}=="
+            @base_client.log_internal :debug, "Save Checkpoint #{deltas.deltas.map {|d| d.id}.max} Thread #{Thread.current.object_id}"
             @base_client.shared_cache.write(cache_key, Prefab::ConfigDeltas.encode(deltas))
           rescue StandardError => exn
-            @base_client.log.info "Issue Checkpointing #{exn.message}"
+            @base_client.log_internal :info, "Issue Checkpointing #{exn.message}"
           end
         end
       end
@@ -126,7 +125,7 @@ module Prefab
               @config_resolver.update
             end
           rescue => e
-            @base_client.log.info("config client encountered #{e.message} pausing #{RECONNECT_WAIT}")
+            @base_client.log_internal :info, ("config client encountered #{e.message} pausing #{RECONNECT_WAIT}")
             reset
             sleep(RECONNECT_WAIT)
           end
@@ -145,7 +144,9 @@ module Prefab
             started_at = Time.now
             config_req = Prefab::ConfigServicePointer.new(account_id: @base_client.account_id,
                                                           start_at_id: start_at_suspenders)
-            resp = stub_with_timeout.get_config(config_req)
+
+            resp = @base_client.request Prefab::ConfigService, :get_config, req_options: {timeout: @timeout}, params: config_req
+
             resp.each do |r|
               r.deltas.each do |delta|
                 @config_loader.set(delta)
@@ -155,7 +156,7 @@ module Prefab
           rescue GRPC::DeadlineExceeded
             # Ignore. This is a streaming endpoint, but we only need a single response
           rescue => e
-            @base_client.log.info "Suspenders encountered an issue #{e.message}"
+            @base_client.log_internal :info, "Suspenders encountered an issue #{e.message}"
           end
 
           delta = SUSPENDERS_FREQ_SEC - (Time.now - started_at)

data/lib/prefab/config_loader.rb

@@ -62,9 +62,10 @@ module Prefab
 
     def load(filename)
       if File.exist? filename
+        @base_client.log_internal :warn, "Load #{filename}"
         YAML.load_file(filename)
       else
-        @base_client.logger.info "No file #{filename}"
+        @base_client.log_internal :warn, "No file #{filename}"
         {}
       end
     end

data/lib/prefab/logger_client.rb

@@ -1,40 +1,58 @@
 module Prefab
   class LoggerClient
 
+    SEP = ".".freeze
+    BASE = "log_level".freeze
+
     def initialize(base_client, base_logger)
       @base_client = base_client
       @base_logger = base_logger
     end
 
-    def info msg
-      pf_log :info, msg, caller_locations(1, 1)[0]
-    end
-
     def debug msg
       pf_log :debug, msg, caller_locations(1, 1)[0]
     end
 
+    def info msg
+      pf_log :info, msg, caller_locations(1, 1)[0]
+    end
+
     def warn msg
       pf_log :warn, msg, caller_locations(1, 1)[0]
     end
 
-    def pf_log level, msg, loc
-      path = loc.absolute_path + ""
+    def error msg
+      pf_log :error, msg, caller_locations(1, 1)[0]
+    end
+
+    def log_for level, msg, loc
+      pf_log_internal level, msg, "", loc
+    end
+
+    private
+
+    def pf_log(level, msg, loc)
+      pf_log_internal level, msg, loc.absolute_path, loc.base_label
+    end
+
+    def pf_log_internal(level, msg, absolute_path, base_label)
+
+      path = absolute_path + ""
       path.slice! Dir.pwd
 
-      path = "#{path.gsub("/", ":").gsub(".rb", "")}:#{loc.base_label}"
-      path.slice! ":"
+      path = "#{path.gsub("/", SEP).gsub(".rb", "")}#{SEP}#{base_label}"
+      path.slice! SEP
 
-      base = "log_level"
-      closest_log_level_match = @base_client.config_client.get(base) || :warn
-      path.split(":").inject([base]) do |memo, n|
+      closest_log_level_match = @base_client.config_client.get(BASE) || :warn
+      path.split(SEP).inject([BASE]) do |memo, n|
         memo << n
-        val = @base_client.config_client.get memo.join(".")
+        val = @base_client.config_client.get memo.join(SEP)
         unless val.nil?
           closest_log_level_match = val
         end
         memo
       end
+
       if val(closest_log_level_match) <= val(level)
         @base_logger.unknown "#{level.to_s.upcase.ljust(5)} #{path} #{msg}"
       end

data/lib/prefab/ratelimit_client.rb

@@ -26,7 +26,7 @@ module Prefab
         allow_partial_response: allow_partial_response
       )
 
-      result = Retry.it(method(:stub), :limit_check, req, @timeout, method(:reset))
+      result = @base_client.request Prefab::RateLimitService, :limit_check, req_options: {timeout: @timeout}, params: req
 
       reset = result.limit_reset_at
       @base_client.shared_cache.write(expiry_cache_key, reset) unless reset < 1 # protobuf default int to 0
@@ -41,19 +41,6 @@ module Prefab
 
     private
 
-    def reset
-      @base_client.reset_channel!
-      @_stub = nil
-    end
-
-    def stub
-      @_stub ||= Prefab::RateLimitService::Stub.new(nil,
-                                                    nil,
-                                                    channel_override: @base_client.channel,
-                                                    timeout: @timeout,
-                                                    interceptors: [@base_client.interceptor])
-    end
-
     def handle_error(e, on_error, groups)
       @base_client.stats.increment("prefab.ratelimit.error", tags: ["type:limit"])
 

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.0.13 ruby lib
+# stub: prefab-cloud-ruby 0.0.14 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "prefab-cloud-ruby".freeze
-  s.version = "0.0.13"
+  s.version = "0.0.14"
 
   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 = "2018-02-13"
+  s.date = "2018-02-20"
   s.description = "RateLimits & Config as a service".freeze
   s.email = "jdwyer@prefab.cloud".freeze
   s.extra_rdoc_files = [
@@ -37,7 +37,6 @@ Gem::Specification.new do |s|
     "lib/prefab/noop_cache.rb",
     "lib/prefab/noop_stats.rb",
     "lib/prefab/ratelimit_client.rb",
-    "lib/prefab/retry.rb",
     "lib/prefab_pb.rb",
     "lib/prefab_services_pb.rb",
     "prefab-cloud-ruby.gemspec",

data/test/.prefab.test.config.yaml

@@ -3,3 +3,4 @@ sample_int: 123
 sample_double: 12.12
 sample_bool: true
 sample_to_override: Foo
+prefab.log_level: debug

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefab-cloud-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-13 00:00:00.000000000 Z
+date: 2018-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grpc
@@ -154,7 +154,6 @@ files:
 - lib/prefab/noop_cache.rb
 - lib/prefab/noop_stats.rb
 - lib/prefab/ratelimit_client.rb
-- lib/prefab/retry.rb
 - lib/prefab_pb.rb
 - lib/prefab_services_pb.rb
 - prefab-cloud-ruby.gemspec

data/lib/prefab/retry.rb

@@ -1,28 +0,0 @@
-class Retry
-  MAX_SLEEP_SEC = 10
-  BASE_SLEEP_SEC = 0.5
-
-  # GRPC Generally handles timeouts for us
-  # but if the connection is broken we want to retry up until the timeout
-  def self.it(stub_factory, rpc, req, timeout, reset)
-    attempts = 0
-    start_time = Time.now
-
-    begin
-      attempts += 1
-      return stub_factory.call.send(rpc, req)
-    rescue => exception
-
-      if Time.now - start_time > timeout
-        raise exception
-      end
-      sleep_seconds = [BASE_SLEEP_SEC * (2 ** (attempts - 1)), MAX_SLEEP_SEC].min
-      sleep_seconds = sleep_seconds * (0.5 * (1 + rand()))
-      sleep_seconds = [BASE_SLEEP_SEC, sleep_seconds].max
-      puts "Sleep #{sleep_seconds} and Reset"
-      sleep sleep_seconds
-      reset.call
-      retry
-    end
-  end
-end