quonfig-openfeature 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15d3186451493a7eeba724e7fb79fce280cb82e9dea6e71a6617db94daca23c5
-  data.tar.gz: eda5a0634c8f48442467a04dd1f454b98531d9b3f6ebc325f97b42e940f32fbe
+  metadata.gz: 518ef7e90608d00dc60292d93fa9c9b6a14037df9194597a1cc309a4c02ea166
+  data.tar.gz: bc52ae8cda109bd7aa20dcc5e0a235716a503d497987d4000d45a97ae6541bba
 SHA512:
-  metadata.gz: d14775ff24ddae1e6f60acf8b0d41de6e6232c41da78bbc3ae7b180f317d6efad58c6d3e347057884244bfaa05746f2cd9f77c1f9110dd33aa652bbe2ee46fd0
-  data.tar.gz: f7346df35c6cfaa28d5b3282cb2aa4a218cb4cdec12407497ede4505240ab3eafadbc08eb016e07312a9d7ea0dc44a2755e9e778766b7a1423d04978ffeb538a
+  metadata.gz: '080feecf4971e26beff1c05427d6ffa0d9c494c26696968502ae7fe8ea462e6eb770a1a57d6486bf8d39093133902b8672cebea3f3f4cd3fc4a92ed0355ba5ae'
+  data.tar.gz: e783174efaa4e7c8577259bec7ebaa7ccc3eb1f900a844fed68e1449cabffeada4b2925fc5d650f15c51c52d27da35a79380bec8d716e6cf4259bd4f5d93ee6b

data/CHANGELOG.md

@@ -1,5 +1,58 @@
 # 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
+  provider does not read `terminal_failure?` or `connection_state`, so nothing in it depends on
+  1.8.0. A fresh `bundle install` / `bundle update quonfig` resolves to 1.8.0, which changes behavior
+  OpenFeature users see through this provider:
+  - **UPGRADE: rule operators follow one cross-SDK semantics (qfg-goi1.5.7).** Pass dates in the
+    evaluation context as epoch milliseconds or ISO 8601 / RFC3339 with `Z` or a numeric offset.
+    Date-only, offset-less and free-form date strings no longer parse, so those `PROP_BEFORE` /
+    `PROP_AFTER` criteria stop matching. Whole-number floats read as plain digits (`1234567.0` ->
+    `"1234567"`) in string operators, and `PROP_SEMVER_*` accepts abbreviated versions (`"4.1"`).
+  - **UPGRADE: a rejected SDK key no longer latches the client off (qfg-goi1.10.26).** A
+    401/403/404/410 poll cycle enters an auth-failed state that probes every 150-300 s and recovers
+    by itself when the key works again, logging one ERROR (status and host, never the key) instead
+    of stopping the stream for the life of the process.
+  - Object flags (`fetch_object_value`) now get a fresh copy of the JSON value on every call, so a
+    caller mutating a resolved Hash or Array no longer changes later resolutions (qfg-goi1.10.3).
+  - Fixes: weighted-rollout `confidential` / `decryptWith` variants are redacted in telemetry
+    (qfg-goi1.2.39), `EnvVarParseError` messages use the cross-SDK wording (qfg-goi1.10.21), and
+    install/SSE robustness fixes (qfg-goi1.10.2, qfg-goi1.2.35).
+
 ## 1.0.2 - 2026-10-09
 
 - Raise the `quonfig` dependency floor from `>= 1.4.0` to `>= 1.7.2` so provider users inherit

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.2
+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.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-09 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