prefab-cloud-ruby 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb91b8be5a01c3bab3312d277a27117c0449713623e1605863486c3809cff0cd
-  data.tar.gz: 3deaeb9fcb458ef461771865463c5163f8b5c6833a45d1e7af4ec3474f5d04bd
+  metadata.gz: e3a735317d9c319aace8ce4cbc99c28a99ed83d23bda5a401c781a6e4e370c51
+  data.tar.gz: c9299c6f257d48b07f90a427d2e6b80b2db8c1daf5e3be5c92df34b3c13d76c3
 SHA512:
-  metadata.gz: 2555fc0364fef33c11e3e7866a00ab5df766e859c73baedbb39712ddceb07ec96d0216c5e79dd7336e40951de85b773100864356fd24423f3257a8e3ab40e073
-  data.tar.gz: 44c9813ede3c95db9820e0247c71c7e4a1e0e21b5981d074025baf546e5f3e7de6362744acedd831437e3b10ca747cdb73ec596ec1394b82ff7e70481ab57a52
+  metadata.gz: 722133d87e4a67ccce34e18d417b40e904da68e686b128badbde3d2a98a5b2b9e0a90f68c001de63cfc9877edf43982f4ffd59bc4dde0dcc6c10e43dc6a3cd83
+  data.tar.gz: 4673e84c936cf72f502402956b846ec14c8cbaaf90d2a90c794e0db4a352f8000cbb1477bd2d43abe685937879cdf6263dc63cfcf0218e7b15265876990c6a84

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## Unreleased
+
+## 1.1.0 - 2023-09-18
+
+- Add support for structured logging (#143)
+    - Ability to pass a hash of key/value context pairs to any of the user-facing log methods
+
+
 ## 1.0.1 - 2023-08-17
 
 - Bug fix for StringList w/ ExampleContextsAggregator (#141)

data/VERSION

@@ -1 +1 @@
-1.0.1
+1.1.0

data/lib/prefab/client.rb

@@ -99,8 +99,8 @@ module Prefab
       resolver.on_update(&block)
     end
 
-    def log_internal(level, msg, path = nil)
-      log.log_internal msg, path, nil, level
+    def log_internal(level, msg, path = nil, **tags)
+      log.log_internal msg, path, nil, level, tags
     end
 
     def enabled?(feature_name, jit_context = NO_DEFAULT_PROVIDED)

data/lib/prefab/context_shape_aggregator.rb

@@ -54,7 +54,7 @@ module Prefab
           end
         )
 
-        result = @client.post('/api/v1/context-shapes', shapes)
+        result = post('/api/v1/context-shapes', shapes)
 
         log_internal "Uploaded #{to_ship.values.size} shapes: #{result.status}"
       end

data/lib/prefab/evaluation_summary_aggregator.rb

@@ -55,7 +55,7 @@ module Prefab
           summaries: summaries(to_ship)
         )
 
-        result = @client.post('/api/v1/telemetry', events(summaries_proto))
+        result = post('/api/v1/telemetry', events(summaries_proto))
 
         log_internal "Uploaded #{to_ship.size} summaries: #{result.status}"
       end

data/lib/prefab/example_contexts_aggregator.rb

@@ -45,7 +45,7 @@ module Prefab
       pool.post do
         log_internal "Flushing #{to_ship.size} examples"
 
-        result = @client.post('/api/v1/telemetry', events(to_ship))
+        result = post('/api/v1/telemetry', events(to_ship))
 
         log_internal "Uploaded #{to_ship.size} examples: #{result.status}"
       end

data/lib/prefab/log_path_aggregator.rb

@@ -25,6 +25,9 @@ module Prefab
 
       @data = Concurrent::Map.new
 
+      @last_data_sent = nil
+      @last_request = nil
+
       start_periodic_sync(sync_interval)
     end
 
@@ -55,7 +58,7 @@ module Prefab
           namespace: @client.namespace
         )
 
-        result = @client.post('/api/v1/known-loggers', loggers)
+        result = post('/api/v1/known-loggers', loggers)
 
         log_internal "Uploaded #{to_ship.size} paths: #{result.status}"
       end

data/lib/prefab/logger_client.rb

@@ -27,26 +27,26 @@ module Prefab
       @log_path_aggregator = log_path_aggregator
     end
 
-    def add_internal(severity, message, progname, loc, &block)
+    def add_internal(severity, message, progname, loc, log_context={}, &block)
       path_loc = get_loc_path(loc)
       path = @prefix + path_loc
 
       @log_path_aggregator&.push(path_loc, severity)
 
-      log(message, path, progname, severity, &block)
+      log(message, path, progname, severity, log_context, &block)
     end
 
-    def log_internal(message, path, progname, severity, &block)
+    def log_internal(message, path, progname, severity, log_context={}, &block)
       path = if path
                "#{INTERNAL_PREFIX}.#{path}"
              else
                INTERNAL_PREFIX
              end
 
-      log(message, path, progname, severity, &block)
+      log(message, path, progname, severity, log_context, &block)
     end
 
-    def log(message, path, progname, severity)
+    def log(message, path, progname, severity, log_context={})
       severity ||= ::Logger::UNKNOWN
 
       return true if @logdev.nil? || severity < level_of(path) || @silences[local_log_id]
@@ -63,29 +63,29 @@ module Prefab
       end
 
       @logdev.write(
-        format_message(format_severity(severity), Time.now, progname, message, path)
+        format_message(format_severity(severity), Time.now, progname, message, path, log_context)
       )
       true
     end
 
-    def debug(progname = nil, &block)
-      add_internal(DEBUG, nil, progname, caller_locations(1, 1)[0], &block)
+    def debug(progname = nil, **log_context, &block)
+      add_internal(DEBUG, nil, progname, caller_locations(1, 1)[0], log_context, &block)
     end
 
-    def info(progname = nil, &block)
-      add_internal(INFO, nil, progname, caller_locations(1, 1)[0], &block)
+    def info(progname = nil, **log_context, &block)
+      add_internal(INFO, nil, progname, caller_locations(1, 1)[0], log_context, &block)
     end
 
-    def warn(progname = nil, &block)
-      add_internal(WARN, nil, progname, caller_locations(1, 1)[0], &block)
+    def warn(progname = nil, **log_context, &block)
+      add_internal(WARN, nil, progname, caller_locations(1, 1)[0], log_context, &block)
     end
 
-    def error(progname = nil, &block)
-      add_internal(ERROR, nil, progname, caller_locations(1, 1)[0], &block)
+    def error(progname = nil, **log_context, &block)
+      add_internal(ERROR, nil, progname, caller_locations(1, 1)[0], log_context, &block)
     end
 
-    def fatal(progname = nil, &block)
-      add_internal(FATAL, nil, progname, caller_locations(1, 1)[0], &block)
+    def fatal(progname = nil, **log_context, &block)
+      add_internal(FATAL, nil, progname, caller_locations(1, 1)[0], log_context, &block)
     end
 
     def debug?
@@ -168,18 +168,17 @@ module Prefab
       path
     end
 
-    def format_message(severity, datetime, progname, msg, path = nil)
+    def format_message(severity, datetime, progname, msg, path = nil, log_context={})
       formatter = (@formatter || @default_formatter)
 
-      if formatter.arity == 5
-        formatter.call(severity, datetime, progname, msg, path)
-      else
-        formatter.call(severity, datetime, join_path_and_progname(path, progname), msg)
-      end
-    end
-
-    def join_path_and_progname(path, progname)
-      (progname.nil? || progname.empty?) ? path : "#{progname}: #{path}"
+      formatter.call(
+        severity: severity,
+        datetime: datetime,
+        progname: progname,
+        path: path,
+        message: msg,
+        log_context: log_context
+      )
     end
   end
 

data/lib/prefab/options.rb

@@ -17,17 +17,23 @@ module Prefab
     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"
+    DEFAULT_LOG_FORMATTER = proc { |data|
+      severity = data[:severity]
+      datetime = data[:datetime]
+      progname = data[:progname]
+      path = data[:path]
+      msg = data[:message]
+      log_context = data[:log_context]
+
+      progname = (progname.nil? || progname.empty?) ? path : "#{progname}: #{path}"
+
+      formatted_log_context = log_context.sort.map{|k, v| "#{k}=#{v}" }.join(" ")
+      "#{severity.ljust(5)} #{datetime}:#{' ' if progname}#{progname} #{msg}#{log_context.any? ? " " + formatted_log_context : ""}\n"
     }
-    JSON_LOG_FORMATTER = proc { |severity, datetime, progname, msg, path|
-      {
-        type: severity,
-        time: datetime,
-        progname: progname,
-        message: msg,
-        path: path
-      }.compact.to_json << "\n"
+
+    JSON_LOG_FORMATTER = proc { |data|
+      log_context = data.delete(:log_context)
+      data.merge(log_context).compact.to_json << "\n"
     }
 
     module ON_INITIALIZATION_FAILURE

data/lib/prefab/periodic_sync.rb

@@ -26,6 +26,10 @@ module Prefab
       # noop -- override as you wish
     end
 
+    def post(url, data)
+      @client.post(url, data)
+    end
+
     def start_periodic_sync(sync_interval)
       @start_at = Prefab::TimeHelpers.now_in_ms
 

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 1.0.1 ruby lib
+# stub: prefab-cloud-ruby 1.1.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "prefab-cloud-ruby".freeze
-  s.version = "1.0.1"
+  s.version = "1.1.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-08-17"
+  s.date = "2023-09-18"
   s.description = "Feature Flags, Live Config, and Dynamic Log Levels as a service".freeze
   s.email = "jdwyer@prefab.cloud".freeze
   s.executables = ["console".freeze]

data/test/integration_test.rb

@@ -1,18 +1,24 @@
 # frozen_string_literal: true
 
 class IntegrationTest
-  attr_reader :func, :input, :expected, :test_client
+  attr_reader :func, :input, :expected, :data, :expected_data, :aggregator, :endpoint, :test_client
 
   def initialize(test_data)
     @client_overrides = parse_client_overrides(test_data['client_overrides'])
     @func = parse_function(test_data['function'])
     @input = parse_input(test_data['input'])
     @expected = parse_expected(test_data['expected'])
-    @test_client = base_client
+    @data = test_data['data']
+    @expected_data = test_data['expected_data']
+    @aggregator = test_data['aggregator']
+    @endpoint = test_data['endpoint']
+    @test_client = capture_telemetry(base_client)
   end
 
   def test_type
-    if @input[0] && @input[0].start_with?('log-level.')
+    if @data
+      :telemetry
+    elsif @input[0] && @input[0].start_with?('log-level.')
       :log_level
     elsif @expected[:status] == 'raise'
       :raise
@@ -23,6 +29,18 @@ class IntegrationTest
     end
   end
 
+  def last_data_sent
+    test_client.last_data_sent
+  end
+
+  def last_post_result
+    test_client.last_post_result
+  end
+
+  def last_post_endpoint
+    test_client.last_post_endpoint
+  end
+
   private
 
   def parse_client_overrides(overrides)
@@ -42,6 +60,8 @@ class IntegrationTest
   end
 
   def parse_input(input)
+    return nil if input.nil?
+
     if input['key']
       parse_config_input(input)
     elsif input['flag']
@@ -62,6 +82,8 @@ class IntegrationTest
   end
 
   def parse_expected(expected)
+    return {} if expected.nil?
+
     {
       status: expected['status'],
       error: parse_error_type(expected['error']),
@@ -73,6 +95,7 @@ class IntegrationTest
   def parse_error_type(error_type)
     case error_type
     when 'missing_default' then Prefab::Errors::MissingDefaultError
+    when 'initialization_timeout' then Prefab::Errors::InitializationTimeoutError
     end
   end
 
@@ -87,7 +110,34 @@ class IntegrationTest
       prefab_envs: ['unit_tests'],
       prefab_datasources: Prefab::Options::DATASOURCES::ALL,
       api_key: ENV['PREFAB_INTEGRATION_TEST_API_KEY'],
-      prefab_api_url: 'https://api.staging-prefab.cloud'
+      prefab_api_url: 'https://api.staging-prefab.cloud',
     }.merge(@client_overrides))
   end
+
+  def capture_telemetry(client)
+    client.define_singleton_method(:post) do |url, data|
+      client.instance_variable_set(:@last_data_sent, data)
+      client.instance_variable_set(:@last_post_endpoint, url)
+
+      result = super(url, data)
+
+      client.instance_variable_set(:@last_post_result, result)
+
+      result
+    end
+
+    client.define_singleton_method(:last_data_sent) do
+      client.instance_variable_get(:@last_data_sent)
+    end
+
+    client.define_singleton_method(:last_post_endpoint) do
+      client.instance_variable_get(:@last_post_endpoint)
+    end
+
+    client.define_singleton_method(:last_post_result) do
+      client.instance_variable_get(:@last_post_result)
+    end
+
+    client
+  end
 end

data/test/integration_test_helpers.rb

@@ -33,4 +33,117 @@ module IntegrationTestHelpers
         .select { |file| file =~ /\.ya?ml$/ }
     end
   end
+
+  def self.prepare_post_data(it)
+    case it.aggregator
+    when "log_path"
+      aggregator = it.test_client.log_path_aggregator
+
+      it.data.each do |(path, data)|
+        data.each_with_index do |count, severity|
+          count.times { aggregator.push(path, severity) }
+        end
+      end
+
+      expected_loggers = Hash.new { |h, k| h[k] = PrefabProto::Logger.new }
+
+      it.expected_data.each do |data|
+        data["counts"].each do |(severity, count)|
+          expected_loggers[data["logger_name"]][severity] = count
+          expected_loggers[data["logger_name"]]["logger_name"] = data["logger_name"]
+        end
+      end
+
+      [aggregator, ->(data) { data.loggers }, expected_loggers.values]
+    when "context_shape"
+      aggregator = it.test_client.context_shape_aggregator
+
+      context = Prefab::Context.new(it.data)
+
+      aggregator.push(context)
+
+      expected = it.expected_data.map do |data|
+        PrefabProto::ContextShape.new(
+          name: data["name"],
+          field_types: data["field_types"]
+        )
+      end
+
+      [aggregator, ->(data) { data.shapes }, expected]
+    when "evaluation_summary"
+      aggregator = it.test_client.evaluation_summary_aggregator
+
+      aggregator.instance_variable_set("@data", Concurrent::Hash.new)
+
+      it.data.each do |key|
+        it.test_client.get(key)
+      end
+
+      expected_data = []
+      it.expected_data.each do |data|
+        value = if data["value_type"] == "string_list"
+                  PrefabProto::StringList.new(values: data["value"])
+                else
+                  data["value"]
+                end
+        expected_data << PrefabProto::ConfigEvaluationSummary.new(
+          key: data["key"],
+          type: data["type"].to_sym,
+          counters: [
+            PrefabProto::ConfigEvaluationCounter.new(
+              count: data["count"],
+              config_id: 0,
+              selected_value: PrefabProto::ConfigValue.new(data["value_type"] => value),
+              config_row_index: data["summary"]["config_row_index"],
+              conditional_value_index: data["summary"]["conditional_value_index"] || 0,
+              weighted_value_index: data["summary"]["weighted_value_index"],
+              reason: :UNKNOWN
+            )
+          ]
+        )
+      end
+
+      [aggregator, ->(data) {
+                     data.events[0].summaries.summaries.each { |e|
+                       e.counters.each { |c|
+                         c.config_id = 0
+                       }
+                     }
+                   }, expected_data]
+    when "example_contexts"
+      aggregator = it.test_client.example_contexts_aggregator
+
+      it.data.each do |hash|
+        aggregator.record(Prefab::Context.new(hash))
+      end
+
+      expected_data = []
+      it.expected_data.each do |data|
+        expected_data << PrefabProto::ExampleContext.new(
+          timestamp: 0,
+          contextSet: PrefabProto::ContextSet.new(
+            contexts: data.map do |(k, vs)|
+              PrefabProto::Context.new(
+                type: k,
+                values: vs.map do |v|
+                  [v["key"], PrefabProto::ConfigValue.new(v["value_type"] => v["value"])]
+                end.to_h
+              )
+            end
+          )
+        )
+      end
+      [aggregator, ->(data) { data.events[0].example_contexts.examples.each { |e| e.timestamp = 0 } }, expected_data]
+    else
+      puts "unknown aggregator #{it.aggregator}"
+    end
+  end
+
+  def self.with_parent_context_maybe(context, &block)
+    if context
+      Prefab::Context.with_context(context, &block)
+    else
+      yield
+    end
+  end
 end

data/test/support/common_helpers.rb

@@ -82,6 +82,16 @@ module CommonHelpers
 
   FakeResponse = Struct.new(:status, :body)
 
+  def wait_for(condition, max_wait: 2, sleep_time: 0.01)
+    wait_time = 0
+    while !condition.call
+      wait_time += sleep_time
+      sleep sleep_time
+
+      raise "Waited #{max_wait} seconds for the condition to be true, but it never was" if wait_time > max_wait
+    end
+  end
+
   def wait_for_post_requests(client, max_wait: 2, sleep_time: 0.01)
     # we use ivars to avoid re-mocking the post method on subsequent calls
     client.instance_variable_set("@_requests", [])
@@ -99,13 +109,7 @@ module CommonHelpers
     yield
 
     # let the flush thread run
-    wait_time = 0
-    while client.instance_variable_get("@_requests").empty?
-      wait_time += sleep_time
-      sleep sleep_time
-
-      raise "Waited #{max_wait} seconds for the flush thread to run, but it never did" if wait_time > max_wait
-    end
+    wait_for -> { client.instance_variable_get("@_requests").size > 0 }, max_wait: max_wait, sleep_time: sleep_time
 
     client.instance_variable_get("@_requests")
   end

data/test/test_integration.rb

@@ -16,7 +16,7 @@ class TestIntegration < Minitest::Test
         define_method(:"test_#{test['name']}_#{test_case['name']}") do
           it = IntegrationTest.new(test_case)
 
-          with_parent_context_maybe(parent_context) do
+          IntegrationTestHelpers.with_parent_context_maybe(parent_context) do
             case it.test_type
             when :raise
               err = assert_raises(it.expected[:error]) do
@@ -34,6 +34,19 @@ class TestIntegration < Minitest::Test
               end
             when :log_level
               assert_equal it.expected[:value].to_sym, it.test_client.send(it.func, *it.input)
+            when :telemetry
+              aggregator, get_actual_data, expected = IntegrationTestHelpers.prepare_post_data(it)
+              aggregator.sync
+
+              wait_for -> { it.last_post_result&.status == 200 }
+
+              assert it.endpoint == it.last_post_endpoint
+
+              actual = get_actual_data[it.last_data_sent]
+
+              expected.all? do |expected|
+                assert actual.include?(expected)
+              end
             else
               raise "Unknown test type: #{it.test_type}"
             end
@@ -42,14 +55,4 @@ class TestIntegration < Minitest::Test
       end
     end
   end
-
-  private
-
-  def with_parent_context_maybe(context, &block)
-    if context
-      Prefab::Context.with_context(context, &block)
-    else
-      yield
-    end
-  end
 end

data/test/test_logger.rb

@@ -404,6 +404,46 @@ class TestLogger < Minitest::Test
     assert_logged io, 'ERROR', 'test.test_logger.test_logging_with_a_block', message
   end
 
+  def test_structured_logging
+    prefab, io = captured_logger
+    message = 'HELLO'
+
+    prefab.log.error message, user: "michael", id: 123
+
+    assert_logged io, 'ERROR', 'test.test_logger.test_structured_logging', "#{message} id=123 user=michael"
+  end
+
+  def test_structured_json_logging
+    prefab, io = captured_logger(log_formatter: Prefab::Options::JSON_LOG_FORMATTER)
+    message = 'HELLO'
+
+    prefab.log.error message, user: "michael", id: 123
+
+    log_data = JSON.parse(io.string)
+    assert log_data["message"] == message
+    assert log_data["user"] == "michael"
+    assert log_data["id"] == 123
+  end
+
+  def test_structured_internal_logging
+    prefab, io = captured_logger
+
+    prefab.log.log_internal('test', 'test.path', '', ::Logger::WARN, user: "michael")
+
+    assert_logged io, 'WARN', 'cloud.prefab.client.test.path', "test user=michael"
+  end
+
+  def test_structured_block_logger
+    prefab, io = captured_logger
+    message = 'MY MESSAGE'
+
+    prefab.log.error user: "michael" do
+      message
+    end
+
+    assert_logged io, 'ERROR', 'test.test_logger.test_structured_block_logger', "#{message} user=michael"
+  end
+
   private
 
   def assert_logged(logged_io, level, path, message)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefab-cloud-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-17 00:00:00.000000000 Z
+date: 2023-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby