quonfig-openfeature 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfe40285fc303f81102212e0c9f7e3df54ec3c1b502df6fddab51f6b69c8b5ff
-  data.tar.gz: c76f4b36468e11354f11a133b64cfd5766ae0b3a31591d30aa70ce100b62cfd4
+  metadata.gz: 518ef7e90608d00dc60292d93fa9c9b6a14037df9194597a1cc309a4c02ea166
+  data.tar.gz: bc52ae8cda109bd7aa20dcc5e0a235716a503d497987d4000d45a97ae6541bba
 SHA512:
-  metadata.gz: bf6a9629d4a67816b6e6c42da14a20b13194d63a6fda798e81249fe2029872537b5edd245cf6587f377244b23963bd5ba8fce8a6e3bcf20e142a212311ed2aee
-  data.tar.gz: a3834afebc880a6f26fe4c3f40e8cf6253393a0a1c47c996df06bef2b7c8df50e24c2c882d86bc93e86394f5b964b79274e7f3b47821d4ab55355ef49370979f
+  metadata.gz: '080feecf4971e26beff1c05427d6ffa0d9c494c26696968502ae7fe8ea462e6eb770a1a57d6486bf8d39093133902b8672cebea3f3f4cd3fc4a92ed0355ba5ae'
+  data.tar.gz: e783174efaa4e7c8577259bec7ebaa7ccc3eb1f900a844fed68e1449cabffeada4b2925fc5d650f15c51c52d27da35a79380bec8d716e6cf4259bd4f5d93ee6b

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 1.1.0 - 2026-10-23
+
+- **UPGRADE: raise the `quonfig` floor from `>= 1.10.0` to `>= 1.11.0`. Requires sdk-ruby 1.11.0:
+  SSE event and config body size caps, `Client#callback_errors_total`.** The provider code does not
+  change for 1.11.0. The new floor means every install of this provider gets those sdk-ruby changes:
+  an oversized SSE event (over 4 MiB) or config body (over 16 MiB) is treated as a failed attempt
+  instead of being read without limit, and `Dir.home` failures no longer raise from `Client.new`.
+  Read the 1.11.0 entry in the sdk-ruby CHANGELOG. Build and test against `quonfig` 1.11.0
+  (Gemfile.lock).
+- **UPGRADE: raise the `quonfig` floor from `>= 1.7.2` to `>= 1.10.0` (qfg-9p4i.12).** The provider
+  now uses sdk-ruby 1.10.0's init-failure surface (`on_init_failure: :fail | :wait | :continue`,
+  `init_timeout_ms`, `Client#ready?` / `#wait_for_ready`, `Quonfig::Errors::InitializationError`).
+  Read the 1.10.0 entry in the sdk-ruby CHANGELOG: `Client.new` now retries a failed boot until
+  `init_timeout_ms` (default 10s) before it raises, instead of raising on the first failed attempt.
+- **Added (minor): the provider emits OpenFeature events and its status follows `on_init_failure`
+  (init-failure design B.5).** Pass `on_init_failure:` and `init_timeout_ms:` to `Provider.new`; they
+  are forwarded to `Quonfig::Client.new` as before.
+  - `:fail` (the default): `init` raises `Quonfig::Errors::InitializationError` when no config loads,
+    so `set_provider_and_wait` raises and the provider is ERROR. sdk-ruby returns no client under
+    `:fail`, so nothing retries in the background; the process restart is the retry.
+  - `:wait`: `init` blocks until config loads. The provider is NOT_READY for the whole wait, then READY.
+  - `:continue` with no config: `init` resolves, then the provider emits `PROVIDER_ERROR` (error code
+    `PROVIDER_NOT_READY`), so its status is ERROR rather than READY while every evaluation returns the
+    code default. When the client's background retry loads config, the provider emits
+    `PROVIDER_READY`. Before, the provider reported READY and emitted no events.
+  - A client injected with `client:` gets the same treatment: if it has no config at `init`, the
+    provider reports ERROR until it heals.
+- **Fix: an evaluation before config loads reports `PROVIDER_NOT_READY`.** sdk-ruby 1.10.0's
+  `*_details` getters return error code `PROVIDER_NOT_READY` on a client with no config; the provider
+  mapped that to `GENERAL`. `Quonfig::Errors::InitializationError` (any reason, not only the timeout
+  subclass) now maps to `PROVIDER_NOT_READY` too.
+
 ## 1.0.3 - 2026-10-16
 
 - Build and test against `quonfig` 1.8.0 (Gemfile.lock). The runtime floor stays at `>= 1.7.2`: this

data/README.md

@@ -56,6 +56,26 @@ is_pro = client.fetch_boolean_value(flag_key: 'pro-feature', default_value: fals
                                      evaluation_context: ctx)
 ```
 
+## Startup failure and provider status
+
+The provider forwards `on_init_failure:` and `init_timeout_ms:` to `Quonfig::Client.new`, and its
+OpenFeature status follows the mode:
+
+| `on_init_failure` | `init` when no config loads | Provider status | Later |
+|-------------------|-----------------------------|-----------------|-------|
+| `:fail` (default) | raises `Quonfig::Errors::InitializationError` after `init_timeout_ms` (at once if the SDK key is rejected) | ERROR | No client exists, so nothing retries; restart the process |
+| `:wait`           | blocks and retries with no upper bound | NOT_READY while waiting | READY when config loads |
+| `:continue`       | returns; emits `PROVIDER_ERROR` | ERROR; evaluations return your default with `PROVIDER_NOT_READY` | emits `PROVIDER_READY` when the background retry loads config |
+
+```ruby
+provider = Quonfig::OpenFeature::Provider.new(
+  sdk_key: 'qf_sk_production_...',
+  on_init_failure: :continue, # :fail (default), :wait or :continue
+  init_timeout_ms: 10_000
+)
+OpenFeature::SDK.set_provider_and_wait(provider)
+```
+
 ## Context mapping
 
 OpenFeature context is flat; Quonfig context is nested by namespace. This provider

data/VERSION

@@ -1 +1 @@
-1.0.3
+1.1.0

data/lib/quonfig/openfeature/errors.rb

@@ -21,7 +21,7 @@ module Quonfig
         return ErrorCode::TYPE_MISMATCH if defined?(::Quonfig::Errors::TypeMismatchError) && err.is_a?(::Quonfig::Errors::TypeMismatchError)
 
         if (defined?(::Quonfig::Errors::UninitializedError) && err.is_a?(::Quonfig::Errors::UninitializedError)) ||
-           (defined?(::Quonfig::Errors::InitializationTimeoutError) && err.is_a?(::Quonfig::Errors::InitializationTimeoutError))
+           (defined?(::Quonfig::Errors::InitializationError) && err.is_a?(::Quonfig::Errors::InitializationError))
           return ErrorCode::PROVIDER_NOT_READY
         end
 

data/lib/quonfig/openfeature/provider.rb

@@ -31,9 +31,26 @@ module Quonfig
     #
     #   client = OpenFeature::SDK.build_client
     #   client.fetch_boolean_value(flag_key: 'my-flag', default_value: false)
+    #
+    # Provider status follows the SDK's +on_init_failure+ mode (init-failure
+    # design B.5). Pass +on_init_failure:+ and +init_timeout_ms:+ through
+    # +Provider.new+; they are forwarded to +Quonfig::Client.new+.
+    #
+    #   * +:fail+ (default): +init+ raises, so the provider is ERROR. sdk-ruby
+    #     returns no client, so nothing retries; restart the process.
+    #   * +:wait+: +init+ blocks until config loads (NOT_READY), then READY.
+    #   * +:continue+: +init+ resolves; with no config yet the provider emits
+    #     PROVIDER_ERROR (ERROR, evaluations return the default with
+    #     PROVIDER_NOT_READY), then PROVIDER_READY when the client heals.
     class Provider
+      include ::OpenFeature::SDK::Provider::EventEmitter
+
       NAME = 'quonfig'
 
+      # How long the heal watcher waits for OpenFeature to record the READY it
+      # dispatches when +init+ returns, before it reports PROVIDER_ERROR.
+      INIT_DISPATCH_WAIT_S = 5
+
       ResolutionDetails = ::OpenFeature::SDK::Provider::ResolutionDetails
       Reason            = ::OpenFeature::SDK::Provider::Reason
       ErrorCode         = ::OpenFeature::SDK::Provider::ErrorCode
@@ -63,16 +80,19 @@ module Quonfig
           environment: environment,
           extra: quonfig_options
         )
-        @initialized = !@client.nil?
+        @initialized = false
       end
 
       # Initialize the underlying Quonfig client. Called by
-      # +OpenFeature::SDK.set_provider_and_wait+.
+      # +OpenFeature::SDK.set_provider_and_wait+. Raises under
+      # +on_init_failure: :fail+ when no config loads, which OpenFeature
+      # records as ERROR.
       def init(_evaluation_context = nil)
         return if @initialized
 
-        @client = ::Quonfig::Client.new(@quonfig_options)
+        @client ||= ::Quonfig::Client.new(@quonfig_options)
         @initialized = true
+        watch_for_heal(@client) unless client_ready?(@client)
         nil
       end
 
@@ -83,6 +103,8 @@ module Quonfig
         @client = nil
         @initialized = false
         client&.stop
+        @heal_thread&.join(1)
+        @heal_thread = nil
         nil
       end
 
@@ -141,6 +163,41 @@ module Quonfig
 
       private
 
+      def client_ready?(client)
+        !client.respond_to?(:ready?) || client.ready?
+      end
+
+      # +on_init_failure: :continue+ left the client without config. Report
+      # ERROR once OpenFeature has recorded the READY it dispatches after +init+
+      # returns, then READY when the client's background retry heals.
+      def watch_for_heal(client)
+        @heal_thread = Thread.new do
+          await_init_dispatch
+          unless client.ready?
+            emit_event(::OpenFeature::SDK::ProviderEvent::PROVIDER_ERROR,
+                       error_code: ErrorCode::PROVIDER_NOT_READY,
+                       message: 'Quonfig has no config yet (on_init_failure: :continue); ' \
+                                'serving code defaults while it retries')
+          end
+          emit_event(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY) if client.wait_for_ready && @client.equal?(client)
+        end
+      end
+
+      # OpenFeature dispatches PROVIDER_READY after +init+ returns. Wait for it
+      # so our PROVIDER_ERROR lands after it, not before. +provider_state+ is
+      # private in openfeature-sdk 0.5.x and public in 0.6.x.
+      def await_init_dispatch
+        config = @configuration
+        return unless config.respond_to?(:provider_state, true)
+
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + INIT_DISPATCH_WAIT_S
+        while config.send(:provider_state, self) == ::OpenFeature::SDK::ProviderState::NOT_READY
+          break if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+
+          sleep 0.01
+        end
+      end
+
       # Map a Quonfig::EvaluationDetails to the OpenFeature ResolutionDetails
       # the SDK consumes. The Quonfig SDK's *_details methods don't raise, so
       # this is a pure mapping layer.
@@ -187,6 +244,7 @@ module Quonfig
         case error_code
         when ::Quonfig::EvaluationDetails::ERROR_FLAG_NOT_FOUND then ErrorCode::FLAG_NOT_FOUND
         when ::Quonfig::EvaluationDetails::ERROR_TYPE_MISMATCH  then ErrorCode::TYPE_MISMATCH
+        when ::Quonfig::EvaluationDetails::ERROR_PROVIDER_NOT_READY then ErrorCode::PROVIDER_NOT_READY
         else ErrorCode::GENERAL
         end
       end
@@ -204,7 +262,7 @@ module Quonfig
 
         mapped_ctx = Context.map_context(evaluation_context, @targeting_key_mapping)
         yield(client, mapped_ctx)
-      rescue ::Quonfig::Errors::UninitializedError, ::Quonfig::Errors::InitializationTimeoutError => e
+      rescue ::Quonfig::Errors::UninitializedError, ::Quonfig::Errors::InitializationError => e
         ResolutionDetails.new(value: default_value, reason: Reason::ERROR,
                               error_code: ErrorCode::PROVIDER_NOT_READY,
                               error_message: e.message)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quonfig-openfeature
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-16 00:00:00.000000000 Z
+date: 2026-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: openfeature-sdk
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.2
+        version: 1.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.2
+        version: 1.11.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement