quonfig 0.0.6 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 875b035905394220e72fec4fc1afc3bc62ad6e2975b745098fa4482e1dc348d0
-  data.tar.gz: bd957d0ec077f3a49daf719deb3ea4db64d1b23a69f6264c91385ad21ff06720
+  metadata.gz: e2dfc7385d529233f3b0b7c5fc13dbe7d0d648851ea0815bde792465a1774319
+  data.tar.gz: f6c702ba4eccdebeda95b8f9341fc0bb077a2c141c9397cb7f3dccb1cbfa782a
 SHA512:
-  metadata.gz: 9a592d367c361e42e57c42b0ca0929927808e834b5f876545e17436403b11eb5abe08d2996317e5ec5360a1df2228b48a247e22304d6fcda809c3ffee0e3f772
-  data.tar.gz: f3f9b9b1135ab775861164fb89701e6a3cf6b5cb23078d55de89604b13081ce71b7fe00bed192cd9d9134d64fd406fec954efa793e62a2fb558a8ca3cddbec4f
+  metadata.gz: 368273026e247c7c01df6e85f11865f94bb588d4c4e512bbc44de65dda0a7659b96a8bd321de6ea676934b9483b0dd99d0fe516d3b288cf93a709f401bbfd824
+  data.tar.gz: be80686fa0c8748c4e1c3f802cfc51c605b1a3e31ec7f9682885a139b5081a79d91d9155833143671bfffa75728bf1091116456defd90bd610d17a5133287e03

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 0.0.8 - 2026-04-26
+
+- **Fix (gemspec): drop deleted `scripts/` entry from manifest** — regenerated
+  juwelier gemspec so `gem build` no longer fails on the missing
+  `scripts/generate_integration_tests.rb` file. Also untracked stray
+  `.DS_Store`. v0.0.7 was tagged but never published due to this bug.
+
+## 0.0.7 - 2026-04-26
+
+- **New: `client.enabled?` / `client.default` / `client.client_construction` integration helpers** —
+  Adds aggregator helpers used by the cross-SDK post + telemetry integration suites.
+- **New: telemetry eval-summaries aggregator + `at_exit` drain (qfg-9x7)** —
+  Periodically batches evaluation summaries and drains them on process exit so
+  short-lived scripts still report telemetry.
+- **New: context telemetry aggregators ported from sdk-node** — context shapes
+  and example-contexts ship through the same aggregator path as sdk-node and
+  sdk-go.
+- **New errors: `DecryptionError`, `MissingEnvironmentError`,
+  `InvalidEnvironmentError`** — explicit error classes raised from the resolver
+  and datadir loaders.
+- **Resolver: provided ENV_VAR resolution + coercion (qfg-08q)** — config values
+  marked `provided` now resolve from the environment at evaluation time and are
+  coerced to the declared value type.
+- **Fix (resolver): raise on missing key, decode weighted/duration/decryption** —
+  `get_or_raise` now raises `MissingDefaultError` for unknown keys, and weighted /
+  duration / decryption value types decode correctly through the JSON resolver.
+- **Fix (context): `grouped_key` drops anonymous contexts** — anonymous contexts
+  are no longer mixed into the grouped-context key, matching sdk-node and sdk-go.
+
 ## 0.0.6 - 2026-04-22
 
 - **New: `Quonfig::StdlibFormatter` + `client.stdlib_formatter(logger_name:)`** —

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.0.9

data/lib/quonfig/bound_client.rb

@@ -40,6 +40,32 @@ module Quonfig
       @client.get_json(key, default: default, context: @context)
     end
 
+    # ---- Details getters ----------------------------------------------
+
+    def get_bool_details(key)
+      @client.get_bool_details(key, context: @context)
+    end
+
+    def get_string_details(key)
+      @client.get_string_details(key, context: @context)
+    end
+
+    def get_int_details(key)
+      @client.get_int_details(key, context: @context)
+    end
+
+    def get_float_details(key)
+      @client.get_float_details(key, context: @context)
+    end
+
+    def get_string_list_details(key)
+      @client.get_string_list_details(key, context: @context)
+    end
+
+    def get_json_details(key)
+      @client.get_json_details(key, context: @context)
+    end
+
     def enabled?(feature_name)
       @client.enabled?(feature_name, @context)
     end

data/lib/quonfig/client.rb

@@ -21,7 +21,7 @@ module Quonfig
     LOG = Quonfig::InternalLogger.new(self)
 
     attr_reader :options, :resolver, :store, :evaluator, :instance_hash,
-                :config_loader
+                :config_loader, :telemetry_reporter
 
     def initialize(options = nil, store: nil, **option_kwargs)
       @options =
@@ -32,7 +32,7 @@ module Quonfig
         else
           Quonfig::Options.new(option_kwargs)
         end
-      @global_context = normalize_context(@options.global_context)
+      @global_context = build_initial_global_context(@options)
       @instance_hash = SecureRandom.uuid
       @store = store || Quonfig::ConfigStore.new
       @evaluator = Quonfig::Evaluator.new(@store, env_id: @options.environment)
@@ -41,6 +41,7 @@ module Quonfig
       @sse_client = nil
       @poll_thread = nil
       @stopped = false
+      @telemetry_reporter = nil
 
       # If the caller injected a store, we're in test/bootstrap mode; skip I/O.
       return if store
@@ -50,15 +51,27 @@ module Quonfig
       else
         initialize_network_mode
       end
+
+      initialize_telemetry
     end
 
     # ---- Lookup --------------------------------------------------------
 
     def get(key, default = NO_DEFAULT_PROVIDED, jit_context = NO_DEFAULT_PROVIDED)
       ctx = build_context(jit_context)
-      result = @resolver.get(key, ctx)
+      record_context_for_telemetry(ctx)
+      result =
+        begin
+          @resolver.get(key, ctx)
+        rescue Quonfig::Errors::MissingDefaultError
+          # The Resolver raises (matching Quonfig.get_or_raise semantics).
+          # The Client's get applies the caller-provided default *or* the
+          # configured on_no_default policy via handle_missing.
+          nil
+        end
       return handle_missing(key, default) if result.nil?
 
+      record_evaluation_for_telemetry(result)
       result.unwrapped_value
     end
 
@@ -90,6 +103,38 @@ module Quonfig
       typed_get(key, :json, default: default, context: context)
     end
 
+    # ---- Details getters ----------------------------------------------
+    #
+    # Mirrors the typed getters above but returns a +Quonfig::EvaluationDetails+
+    # carrying the OpenFeature-aligned resolution +reason+ ("STATIC",
+    # "TARGETING_MATCH", "SPLIT", "DEFAULT", or "ERROR") plus an
+    # +error_code+/+error_message+ on the error path. These methods never
+    # raise — exceptions are caught and rendered as ERROR details.
+
+    def get_bool_details(key, context: NO_DEFAULT_PROVIDED)
+      evaluate_details(key, :bool, context)
+    end
+
+    def get_string_details(key, context: NO_DEFAULT_PROVIDED)
+      evaluate_details(key, String, context)
+    end
+
+    def get_int_details(key, context: NO_DEFAULT_PROVIDED)
+      evaluate_details(key, Integer, context)
+    end
+
+    def get_float_details(key, context: NO_DEFAULT_PROVIDED)
+      evaluate_details(key, Float, context)
+    end
+
+    def get_string_list_details(key, context: NO_DEFAULT_PROVIDED)
+      evaluate_details(key, :string_list, context)
+    end
+
+    def get_json_details(key, context: NO_DEFAULT_PROVIDED)
+      evaluate_details(key, :json, context)
+    end
+
     def enabled?(feature_name, jit_context = NO_DEFAULT_PROVIDED)
       value = get(feature_name, false, jit_context)
       value == true || value == 'true'
@@ -223,6 +268,13 @@ module Quonfig
       thread = @poll_thread
       @poll_thread = nil
       thread&.kill
+
+      begin
+        @telemetry_reporter&.stop
+      rescue StandardError => e
+        LOG.debug "Error stopping telemetry reporter: #{e.message}"
+      end
+      @telemetry_reporter = nil
     end
 
     def fork
@@ -235,6 +287,93 @@ module Quonfig
 
     private
 
+    # Construct and start the telemetry reporter if the options permit it.
+    # The reporter runs on a background thread and periodically POSTs
+    # context-shape and example-context batches to +telemetry_destination+.
+    def initialize_telemetry
+      shape_aggregator = nil
+      example_aggregator = nil
+      summaries_aggregator = nil
+
+      if @options.collect_max_shapes.to_i > 0
+        shape_aggregator = Quonfig::Telemetry::ContextShapeAggregator.new(
+          max_shapes: @options.collect_max_shapes
+        )
+      end
+
+      if @options.collect_max_example_contexts.to_i > 0
+        example_aggregator = Quonfig::Telemetry::ExampleContextsAggregator.new(
+          max_contexts: @options.collect_max_example_contexts
+        )
+      end
+
+      if @options.collect_max_evaluation_summaries.to_i > 0
+        summaries_aggregator = Quonfig::Telemetry::EvaluationSummariesAggregator.new(
+          max_keys: @options.collect_max_evaluation_summaries
+        )
+      end
+
+      return if shape_aggregator.nil? && example_aggregator.nil? && summaries_aggregator.nil?
+
+      @telemetry_reporter = Quonfig::Telemetry::TelemetryReporter.new(
+        options: @options,
+        instance_hash: @instance_hash,
+        context_shape_aggregator: shape_aggregator,
+        example_contexts_aggregator: example_aggregator,
+        evaluation_summaries_aggregator: summaries_aggregator,
+        sync_interval: @options.collect_sync_interval
+      )
+
+      return unless @telemetry_reporter.enabled?
+
+      @telemetry_reporter.start
+    rescue StandardError => e
+      LOG.warn "[quonfig] Telemetry init failed: #{e.class}: #{e.message}"
+      @telemetry_reporter = nil
+    end
+
+    # Feed a matched EvalResult into the evaluation_summaries aggregator.
+    # A no-op when telemetry is disabled or eval-summaries collection is off.
+    def record_evaluation_for_telemetry(result)
+      return if @telemetry_reporter.nil?
+      return if result.nil?
+
+      config = result.config
+      return if config.nil?
+
+      @telemetry_reporter.record_evaluation(
+        config_id: config_field(config, :id),
+        config_key: config_field(config, :key),
+        config_type: config_field(config, :type),
+        conditional_value_index: result.rule_index,
+        weighted_value_index: result.weighted_value_index,
+        selected_value: result.unwrapped_value,
+        reason: result.wire_reason
+      )
+    rescue StandardError => e
+      LOG.debug "[quonfig] Telemetry record_evaluation error: #{e.class}: #{e.message}"
+    end
+
+    def config_field(config, key)
+      return nil if config.nil?
+
+      config[key.to_s] || config[key.to_sym]
+    end
+
+    # Feed every evaluated context into the telemetry aggregators. A no-op
+    # when telemetry is disabled or no aggregators are active.
+    def record_context_for_telemetry(context)
+      return if @telemetry_reporter.nil?
+      return if context.nil?
+
+      context_obj = context.is_a?(Quonfig::Context) ? context : Quonfig::Context.new(context)
+      return if context_obj.blank?
+
+      @telemetry_reporter.record(context_obj)
+    rescue StandardError => e
+      LOG.debug "[quonfig] Telemetry record error: #{e.class}: #{e.message}"
+    end
+
     def load_datadir_into_store
       envelope = Quonfig::Datadir.load_envelope(@options.datadir, @options.environment)
       envelope.configs.each { |cfg| @store.set(cfg['key'], cfg) }
@@ -334,6 +473,21 @@ module Quonfig
       merge_contexts(@global_context, jit)
     end
 
+    # Combine the customer-supplied globalContext with the optional dev
+    # context loaded from ~/.quonfig/tokens.json. Dev context goes UNDER the
+    # customer's so any explicit `quonfig-user` keys win on collision.
+    def build_initial_global_context(options)
+      customer = normalize_context(options.global_context)
+      enabled = options.enable_quonfig_user_context == true ||
+                ENV['QUONFIG_DEV_CONTEXT'] == 'true'
+      return customer unless enabled
+
+      dev = Quonfig::DevContext.load_quonfig_user_context
+      return customer if dev.nil?
+
+      merge_contexts(dev, customer)
+    end
+
     def normalize_context(ctx)
       return {} if ctx.nil?
       return ctx if ctx.is_a?(Hash)
@@ -378,6 +532,61 @@ module Quonfig
       nil
     end
 
+    # Build a Quonfig::EvaluationDetails for +key+, evaluated against the
+    # caller's context, after coercing/checking +expected_type+. Never
+    # raises; all exceptions become ERROR details.
+    def evaluate_details(key, expected_type, context)
+      jit = context == NO_DEFAULT_PROVIDED ? nil : context
+      ctx = build_context(jit)
+      record_context_for_telemetry(ctx)
+
+      result =
+        begin
+          @resolver.get(key, ctx)
+        rescue Quonfig::Errors::MissingDefaultError => e
+          return Quonfig::EvaluationDetails.new(
+            value: nil,
+            reason: Quonfig::EvaluationDetails::REASON_ERROR,
+            error_code: Quonfig::EvaluationDetails::ERROR_FLAG_NOT_FOUND,
+            error_message: e.message
+          )
+        end
+
+      if result.nil?
+        return Quonfig::EvaluationDetails.new(
+          value: nil,
+          reason: Quonfig::EvaluationDetails::REASON_DEFAULT
+        )
+      end
+
+      record_evaluation_for_telemetry(result)
+
+      raw_value = result.unwrapped_value
+
+      begin
+        coerced = coerce_and_check(key, raw_value, expected_type) unless raw_value.nil?
+      rescue Quonfig::Errors::TypeMismatchError => e
+        return Quonfig::EvaluationDetails.new(
+          value: nil,
+          reason: Quonfig::EvaluationDetails::REASON_ERROR,
+          error_code: Quonfig::EvaluationDetails::ERROR_TYPE_MISMATCH,
+          error_message: e.message
+        )
+      end
+
+      Quonfig::EvaluationDetails.new(
+        value: coerced,
+        reason: result.of_reason
+      )
+    rescue StandardError => e
+      Quonfig::EvaluationDetails.new(
+        value: nil,
+        reason: Quonfig::EvaluationDetails::REASON_ERROR,
+        error_code: Quonfig::EvaluationDetails::ERROR_GENERAL,
+        error_message: e.message
+      )
+    end
+
     def typed_get(key, expected_type, default:, context:)
       jit = context == NO_DEFAULT_PROVIDED ? NO_DEFAULT_PROVIDED : context
       value = get(key, default, jit)

data/lib/quonfig/context.rb

@@ -85,8 +85,17 @@ module Quonfig
       @contexts[name.to_s] || NamedContext.new(name, {})
     end
 
+    # Concatenate each named context's `key` (or `trackingId`) value into
+    # a stable identifier used for example-contexts dedupe. Mirrors
+    # sdk-node's groupedKey: contexts that don't have a `key` property
+    # contribute nothing — the resulting string is empty for "anonymous"
+    # contexts so the example aggregator can drop them entirely.
     def grouped_key
-      @contexts.map { |_, ctx| ctx.key }.sort.join('|')
+      @contexts.values.map do |ctx|
+        h = ctx.to_h
+        v = h['key'] || h[:key] || h['trackingId'] || h[:trackingId]
+        v.nil? ? nil : v.to_s
+      end.compact.reject(&:empty?).sort.join('|')
     end
 
     include Comparable

data/lib/quonfig/datadir.rb

@@ -59,8 +59,7 @@ module Quonfig
       environment ||= ENV['QUONFIG_ENVIRONMENT']
 
       if environment.nil? || environment.empty?
-        raise ArgumentError,
-              '[quonfig] Environment required for datadir mode; set the `environment` option or QUONFIG_ENVIRONMENT env var'
+        raise Quonfig::Errors::MissingEnvironmentError
       end
 
       unless File.exist?(quonfig_path)
@@ -70,8 +69,7 @@ module Quonfig
       environments = JSON.parse(File.read(quonfig_path)).fetch('environments', [])
 
       if !environments.empty? && !environments.include?(environment)
-        raise ArgumentError,
-              "[quonfig] Environment \"#{environment}\" not found in workspace; available environments: #{environments.join(', ')}"
+        raise Quonfig::Errors::InvalidEnvironmentError.new(environment, environments)
       end
 
       environment

data/lib/quonfig/dev_context.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Quonfig
+  # Dev-only context loader. Reads ~/.quonfig/tokens.json (written by
+  # `qfg login`) and returns {'quonfig-user' => {'email' => ...}} when a
+  # userEmail is present. Returns nil when the file is missing, unreadable,
+  # or has no userEmail.
+  #
+  # The attribute is dev-only by construction: production servers do not
+  # run `qfg login` and therefore have no tokens file. Rules keyed on
+  # `quonfig-user.email` are dead code in prod.
+  module DevContext
+    TOKENS_BASENAME = File.join('.quonfig', 'tokens.json')
+
+    def self.load_quonfig_user_context
+      path = File.join(Dir.home, TOKENS_BASENAME)
+      return nil unless File.exist?(path)
+
+      raw = begin
+        File.read(path)
+      rescue StandardError => e
+        warn "[quonfig] dev-context: could not read #{path} (#{e.class}: #{e.message}); skipping injection"
+        return nil
+      end
+
+      parsed = begin
+        JSON.parse(raw)
+      rescue JSON::ParserError => e
+        warn "[quonfig] dev-context: could not parse #{path} (#{e.message}); skipping injection"
+        return nil
+      end
+
+      email = parsed.is_a?(Hash) ? parsed['userEmail'] : nil
+      return nil unless email.is_a?(String) && !email.empty?
+
+      { 'quonfig-user' => { 'email' => email } }
+    end
+  end
+end

data/lib/quonfig/errors/decryption_error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Quonfig
+  module Errors
+    # Raised when a confidential config's ciphertext cannot be decrypted —
+    # either the configured `decryptWith` key is missing/empty, or the
+    # AES-GCM payload itself is malformed/tampered.
+    #
+    # Mirrors sdk-python's QuonfigDecryptionError. Sdk-node currently
+    # raises plain `Error` for the same path; this class is the Ruby
+    # equivalent of the dedicated exception type.
+    class DecryptionError < Quonfig::Error
+      def initialize(key, cause = nil)
+        message = "Decryption failed for config '#{key}'"
+        message += ": #{cause}" if cause && !cause.to_s.empty?
+        super(message)
+      end
+    end
+  end
+end

data/lib/quonfig/errors/env_var_parse_error.rb

@@ -4,7 +4,14 @@ module Quonfig
   module Errors
     class EnvVarParseError < Quonfig::Error
       def initialize(env_var, config, env_var_name)
-        super("Evaluating #{config.key} couldn't coerce #{env_var_name} of #{env_var} to #{config.value_type}")
+        key, value_type =
+          if config.is_a?(Hash)
+            [config[:key] || config['key'],
+             config[:value_type] || config['value_type'] || config['valueType']]
+          else
+            [config.key, config.value_type]
+          end
+        super("Evaluating #{key} couldn't coerce #{env_var_name} of #{env_var} to #{value_type}")
       end
     end
   end

data/lib/quonfig/errors/invalid_environment_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Quonfig
+  module Errors
+    # Raised when the requested environment (via `environment:` option or
+    # QUONFIG_ENVIRONMENT) isn't listed in the workspace's `quonfig.json`.
+    # Catches typos like `"prdoduction"` early instead of silently
+    # evaluating against default rules.
+    class InvalidEnvironmentError < Quonfig::Error
+      def initialize(environment, available = nil)
+        message = "[quonfig] Environment \"#{environment}\" not found in workspace"
+        if available && !Array(available).empty?
+          message += "; available environments: #{Array(available).join(', ')}"
+        end
+        super(message)
+      end
+    end
+  end
+end

data/lib/quonfig/errors/missing_environment_error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Quonfig
+  module Errors
+    # Raised when datadir mode is engaged but no environment was supplied
+    # (neither the `environment:` option nor the QUONFIG_ENVIRONMENT env
+    # var is set). Datadir mode requires an explicit environment; without
+    # one the loader cannot pick the right environment row from each
+    # config's `environments` array.
+    class MissingEnvironmentError < Quonfig::Error
+      def initialize(message = nil)
+        message ||= '[quonfig] Environment required for datadir mode; ' \
+                    'set the `environment` option or QUONFIG_ENVIRONMENT env var'
+        super(message)
+      end
+    end
+  end
+end

data/lib/quonfig/evaluator.rb

@@ -409,14 +409,73 @@ module Quonfig
   # raw JSON Value hash (#value) and a coerced Ruby value (#unwrapped_value).
   # The test suite and integration helpers consume both shapes.
   class EvalResult
-    attr_reader :value, :rule_index, :config
+    # Integer reason codes for the api-telemetry EvalSummaries wire
+    # format. Match sdk-node/src/reason.ts.
+    REASON_UNKNOWN          = 0
+    REASON_STATIC           = 1
+    REASON_TARGETING_MATCH  = 2
+    REASON_SPLIT            = 3
 
-    def initialize(value:, rule_index:, config:)
+    attr_reader :value, :rule_index, :config, :reportable_value
+    attr_accessor :weighted_value_index
+
+    def initialize(value:, rule_index:, config:, weighted_value_index: nil, reportable_value: nil)
       @value = value
       @rule_index = rule_index
       @config = config
+      @weighted_value_index = weighted_value_index
+      # Telemetry-safe substitute for #unwrapped_value. Set by Resolver when
+      # the underlying Value was confidential / decryptWith, so callers
+      # (the eval-summary aggregator) never see the plaintext. Mirrors
+      # ReforgeHQ/sdk-ruby ConfigValueUnwrapper#reportable_value (the
+      # `*****<5-md5>` hash form).
+      @reportable_value = reportable_value
+    end
+
+    # Integer reason code for telemetry. Mirrors sdk-node's computeReason:
+    # SPLIT when a weighted variant is picked, STATIC when the first rule
+    # of a config with no targeting rules matched, otherwise TARGETING_MATCH.
+    def wire_reason
+      return REASON_SPLIT unless @weighted_value_index.nil?
+      return REASON_STATIC if @rule_index == 0 && !EvalResult.send(:targeting_rules?, @config)
+
+      REASON_TARGETING_MATCH
+    end
+
+    # OpenFeature-aligned reason string. Same classification logic as
+    # +wire_reason+ but as a public string the OF provider (and any
+    # third-party consumer of EvaluationDetails) can pass straight through.
+    #
+    # Returns one of: "STATIC", "TARGETING_MATCH", "SPLIT".
+    def of_reason
+      case wire_reason
+      when REASON_STATIC          then EvaluationDetails::REASON_STATIC
+      when REASON_SPLIT           then EvaluationDetails::REASON_SPLIT
+      else                             EvaluationDetails::REASON_TARGETING_MATCH
+      end
     end
 
+    # True if any rule on the config (default or environment) has a
+    # non-ALWAYS_TRUE criterion. Used to decide STATIC vs TARGETING_MATCH.
+    def self.targeting_rules?(config)
+      return false if config.nil?
+
+      rules = []
+      %i[default environment].each do |section_key|
+        section = config[section_key.to_s] || config[section_key]
+        next if section.nil?
+
+        section_rules = section['rules'] || section[:rules] || []
+        rules.concat(section_rules)
+      end
+
+      rules.any? do |rule|
+        criteria = rule['criteria'] || rule[:criteria] || []
+        criteria.any? { |c| (c['operator'] || c[:operator]) != 'ALWAYS_TRUE' }
+      end
+    end
+    private_class_method :targeting_rules?
+
     # Raw underlying value without type coercion.
     def raw_value
       return nil if @value.nil?
@@ -446,7 +505,7 @@ module Quonfig
       when 'string'      then raw.to_s
       when 'string_list' then raw.is_a?(Array) ? raw.map(&:to_s) : []
       when 'log_level'   then raw.is_a?(Numeric) ? raw : raw.to_s
-      when 'duration'    then raw.to_s
+      when 'duration'    then duration_to_millis(raw)
       when 'json'
         # JSON values must be native JS/Ruby types on the wire.
         raw
@@ -460,5 +519,27 @@ module Quonfig
     def value_type
       type
     end
+
+    private
+
+    # Coerce an ISO 8601 duration value (e.g. "PT0.2S", "P1DT6H2M1.5S")
+    # to integer milliseconds. The wire format may either be a bare ISO
+    # string in `value` or the structured `{ seconds, nanos }` proto-style
+    # shape. Mirrors sdk-node Resolver#unwrapValue duration branch.
+    def duration_to_millis(raw)
+      case raw
+      when Numeric
+        raw.to_i
+      when String
+        seconds = Quonfig::Duration.parse(raw)
+        (seconds * 1000).round
+      when Hash
+        secs = (raw['seconds'] || raw[:seconds] || 0).to_f
+        nanos = (raw['nanos']   || raw[:nanos]   || 0).to_f
+        (secs * 1000 + nanos / 1_000_000.0).round
+      else
+        raw
+      end
+    end
   end
 end

data/lib/quonfig/http_connection.rb

@@ -5,7 +5,7 @@ require 'json'
 
 module Quonfig
   class HttpConnection
-    SDK_VERSION = 'ruby-0.1.0'
+    SDK_VERSION = "ruby-#{Quonfig::VERSION}".freeze
 
     JSON_HEADERS = {
       'Content-Type' => 'application/json',

data/lib/quonfig/options.rb

@@ -21,6 +21,7 @@ module Quonfig
     attr_reader :poll_interval
     attr_reader :global_context
     attr_reader :logger_key
+    attr_reader :enable_quonfig_user_context
     attr_accessor :is_fork
 
     module ON_INITIALIZATION_FAILURE
@@ -74,7 +75,8 @@ module Quonfig
       collect_max_evaluation_summaries: DEFAULT_MAX_EVAL_SUMMARIES,
       allow_telemetry_in_local_mode: false,
       global_context: {},
-      logger_key: nil
+      logger_key: nil,
+      enable_quonfig_user_context: false
     )
       @sdk_key = sdk_key
       @environment = environment
@@ -94,6 +96,7 @@ module Quonfig
       @is_fork = false
       @global_context = global_context
       @logger_key = logger_key
+      @enable_quonfig_user_context = enable_quonfig_user_context
 
       # defaults that may be overridden by context_upload_mode
       @collect_shapes = false