quonfig 0.0.10 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94866b65b3e3c4e834897981847da01f350984b2f7126f8259318ba385b8fd77
-  data.tar.gz: bc173a4300c1475f596921de2a2d24e02e5de648503318491a602c19123dd329
+  metadata.gz: 3ae93c1a78be83e339ff86bf9eaa58efa3376602c363ddd1d4c6e326fe102865
+  data.tar.gz: 38debe8196e6a9ae1f5281b810d0193a4d8a821a45bb18afeaf103732f1d92d7
 SHA512:
-  metadata.gz: 875265c218e5a465abced6d47563ef7c86ade61ca2d98367059bc800dec55e1148badf58e60b632e468ab565ef5ec80e587b8f0fd045f5300b000f64fe12b909
-  data.tar.gz: 6725f7b13ac6ba43d0e7903963c5de4b1bbe03f1ae7e51399e4d0cc8877f6ee637ef2850e396e65c8d5c44cac2ee7cfa0b2f1724d390d43746d421d7e465c42a
+  metadata.gz: de28a9ffb64be4d7a5c3c4982a13713cfd44ba0abcef4bbbcf3a385de9ddd881fe814e319d6770ec572f7b9655e8cc6f466d887040fa300e4d9513dce54e045e
+  data.tar.gz: 0c1ac8d2e32d95534f0f903d0fa6df1a2a627a4d7f5f68a27e14448230e67804b3c859e0e1d551cde7c7ce6e2a7c453ebfb67aee7f30e1834753130328344663

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.0.12 - 2026-05-03
+
+- **Feat: pluggable `logger:` kwarg on `Quonfig::Client.new`.** Host apps can now pass `Rails.logger` (or any stdlib `Logger`-compatible instance) and have all SDK warnings/errors flow through it instead of bare stderr / SemanticLogger. Implemented as a class-level `Quonfig::InternalLogger.user_logger` override that all `LOG` constants respect at log-call time, so existing per-class `LOG` constants pick it up automatically. Duck-typed (responds to `debug`/`info`/`warn`/`error`); missing levels degrade gracefully. SemanticLogger auto-detection is unchanged when no logger is supplied. Also routes the two outlier `dev_context.rb` warns (file read / JSON parse failures) through `InternalLogger` so they pick up the host-supplied logger too. (qfg-mol-1qw.3)
+
+## 0.0.11 - 2026-05-02
+
+- **Fix (telemetry): SSE clientName attribution.** The SSE client was sending
+  `X-Quonfig-SDK-Version: sdk-ruby-<version>`, which the api-telemetry parser
+  splits on the first dash, so it landed as `clientName="sdk"`,
+  `clientVersion="ruby-<version>"`. Now sends `ruby-<version>` to match
+  `http_connection.rb`, so both transports attribute consistently as
+  `clientName="ruby"`.
+- **Release plumbing: drop juwelier, tag-triggered publish.** The gem is now
+  built from a hand-written `quonfig.gemspec` that reads the version from
+  `Quonfig::VERSION` (in `lib/quonfig/version.rb`) and lists shipped files
+  explicitly. The `release.yml` workflow now fires on `v*` tag pushes, not
+  every successful main build, and refuses to publish unless the tag matches
+  `Quonfig::VERSION`. Together these eliminate the gemspec-vs-VERSION drift
+  that prevented the original 0.0.11 publish (gem built as 0.0.10 internally
+  while filename said 0.0.11) and the manifest-drift bug from qfg-e588.
+
 ## 0.0.10 - 2026-05-01
 
 - **BREAKING (env): `QUONFIG_TELEMETRY_URL` and `QUONFIG_API_URLS` env vars
@@ -16,6 +37,15 @@
   `telemetry_url:` kwarg (was previously documented but not wired up).
 - **Default `api_urls` now includes secondary.** Was `[primary]`, now
   `[primary, secondary]` to match every other SDK and provide failover.
+- **Release plumbing: pre-publish smoke check (qfg-e588).** The Rakefile
+  `:release` task and the `release.yml` workflow now run
+  `scripts/smoke_check.sh` after `gem build` and before `gem push`. The
+  script installs the freshly built `.gem` into a sandbox `GEM_HOME` and
+  shells out to `ruby -rquonfig -e 'puts Quonfig::VERSION'`. If the
+  require fails or the version mismatches, the publish aborts. This is
+  the prevention measure for qfg-e588, where 0.0.9 was published with a
+  stale gemspec manifest missing `lib/quonfig/evaluation_details.rb` and
+  every consumer hit `LoadError` at install time.
 
 ## 0.0.8 - 2026-04-26
 

data/README.md

@@ -147,6 +147,7 @@ Quonfig::Client.new(
 | `global_context`  | `Hash`                     | `{}`                                                                | Context applied to every evaluation.                                                              |
 | `datadir`         | `String`                   | `ENV['QUONFIG_DIR']`                                                | Path to a local workspace. When set, the SDK runs offline from disk.                              |
 | `environment`     | `String`                   | `ENV['QUONFIG_ENVIRONMENT']`                                        | Environment to evaluate in datadir mode. Required when `datadir` is set.                          |
+| `logger`          | Logger-like object         | `nil`                                                               | Optional host-app logger (e.g. `Rails.logger`). Must respond to `debug`/`info`/`warn`/`error`. When set, all SDK warnings/errors flow through this logger instead of the default stderr / SemanticLogger backend. |
 
 ## Typed getters
 
@@ -239,6 +240,99 @@ logger.progname  = 'MyApp::Services::Auth'
 
 If both are supplied, the explicit `logger_name:` wins.
 
+## Rails integration
+
+The SDK runs a background SSE thread (and optional polling thread) that you do
+not want to inherit across a `fork(2)`. Forked threads in the child process
+are dead — the SSE socket is held open by a thread that no longer exists, and
+the child silently stops receiving live updates.
+
+Use `Quonfig::Client#fork` (or `Quonfig.fork` if you use the module-level
+singleton) in any process that fork-spawns workers. It returns a fresh client
+configured for the child: a new `ConfigStore`, a new SSE subscription, and
+suppressed telemetry double-counting (`Options#is_fork` is set to `true`).
+
+### Puma (clustered mode)
+
+```ruby
+# config/puma.rb
+before_fork do
+  Quonfig.instance.stop          # close the master's SSE before forking
+end
+
+on_worker_boot do
+  Quonfig.fork                   # rebuild a fresh client per worker
+end
+```
+
+If you initialize Quonfig lazily (in a Rails initializer) and run Puma in
+single mode (no clustering), no fork hook is needed.
+
+### Sidekiq
+
+Sidekiq's parent process forks workers. Wire the same lifecycle:
+
+```ruby
+# config/initializers/quonfig.rb
+Quonfig.init(Quonfig::Options.new(sdk_key: ENV.fetch('QUONFIG_BACKEND_SDK_KEY')))
+
+# config/initializers/sidekiq.rb
+Sidekiq.configure_server do |config|
+  config.on(:startup)  { Quonfig.fork if Process.ppid != 1 }
+  config.on(:shutdown) { Quonfig.instance.stop rescue nil }
+end
+```
+
+For Sidekiq web/CLI processes that don't fork (default `concurrency: 1`),
+`Quonfig.init` in the initializer is sufficient.
+
+### Spring / Bootsnap preloaders
+
+Spring forks the preloader for each command. If your initializer creates a
+Quonfig client at boot, the SSE thread will be inherited dead in every child.
+Two options:
+
+1. **Recommended:** initialize lazily — wrap `Quonfig.init` so it only runs
+   the first time `Quonfig.instance` is called from a non-preloader process.
+2. **Or:** call `Quonfig.fork` from a `Spring.after_fork` hook.
+
+```ruby
+# config/spring.rb
+Spring.after_fork do
+  Quonfig.fork if defined?(Quonfig) && Quonfig.instance_variable_get(:@singleton)
+end
+```
+
+### Code reloading (Zeitwerk, development mode)
+
+`Quonfig::Client` is a long-lived object — keep it out of `app/` (where
+Zeitwerk reloads classes on every request) and pin it to a constant set in a
+Rails initializer. The client itself is reload-safe because it does not
+reference any application classes; the failure mode to avoid is *creating a
+new client per request*, which leaks SSE threads and quickly exhausts file
+descriptors.
+
+```ruby
+# config/initializers/quonfig.rb
+# Quonfig.init is idempotent — a second call warns and returns the existing
+# singleton — so it's safe to wrap in to_prepare for reload-friendliness.
+Rails.application.config.to_prepare do
+  Quonfig.init(Quonfig::Options.new(sdk_key: ENV.fetch('QUONFIG_BACKEND_SDK_KEY')))
+end
+```
+
+## Thread safety
+
+`Quonfig::Client` is safe to share across threads. Reads (`get`, `enabled?`,
+`get_*`) and SSE-driven writes to the underlying `ConfigStore` use
+`Concurrent::Map` for per-key atomicity. Eventual consistency across an
+envelope is intentional: a reader concurrent with envelope application may
+observe the new value for some keys and the old value for others, then
+converge once the envelope finishes applying.
+
+`Quonfig.fork` is the only safe way to "carry" a client across `Process.fork`
+— do not reuse the parent's client in a child process.
+
 ## Documentation
 
 Full documentation, including SPEC, SDK reference, and operational guides, is

data/lib/quonfig/caching_http_connection.rb

@@ -2,7 +2,7 @@
 
 module Quonfig
   class CachingHttpConnection
-    CACHE_SIZE = 2.freeze
+    CACHE_SIZE = 2
     CacheEntry = Struct.new(:data, :etag, :expires_at)
 
     class << self
@@ -68,7 +68,7 @@ module Quonfig
       return response if cache_control.include?('no-store')
 
       # Calculate expiration
-      max_age = cache_control.match(/max-age=(\d+)/)&.captures&.first&.to_i
+      max_age = cache_control[/max-age=(\d+)/, 1]&.to_i
       expires_at = max_age ? now + max_age : nil
 
       # Cache the response if we have caching headers
@@ -92,4 +92,4 @@ module Quonfig
       @connection.uri
     end
   end
-end
+end

data/lib/quonfig/client.rb

@@ -32,6 +32,7 @@ module Quonfig
         else
           Quonfig::Options.new(option_kwargs)
         end
+      Quonfig::InternalLogger.user_logger = @options.logger if @options.logger
       @global_context = build_initial_global_context(@options)
       @instance_hash = SecureRandom.uuid
       @store = store || Quonfig::ConfigStore.new
@@ -137,7 +138,7 @@ module Quonfig
 
     def enabled?(feature_name, jit_context = NO_DEFAULT_PROVIDED)
       value = get(feature_name, false, jit_context)
-      value == true || value == 'true'
+      [true, 'true'].include?(value)
     end
 
     def defined?(key)
@@ -295,19 +296,19 @@ module Quonfig
       example_aggregator = nil
       summaries_aggregator = nil
 
-      if @options.collect_max_shapes.to_i > 0
+      if @options.collect_max_shapes.to_i.positive?
         shape_aggregator = Quonfig::Telemetry::ContextShapeAggregator.new(
           max_shapes: @options.collect_max_shapes
         )
       end
 
-      if @options.collect_max_example_contexts.to_i > 0
+      if @options.collect_max_example_contexts.to_i.positive?
         example_aggregator = Quonfig::Telemetry::ExampleContextsAggregator.new(
           max_contexts: @options.collect_max_example_contexts
         )
       end
 
-      if @options.collect_max_evaluation_summaries.to_i > 0
+      if @options.collect_max_evaluation_summaries.to_i.positive?
         summaries_aggregator = Quonfig::Telemetry::EvaluationSummariesAggregator.new(
           max_keys: @options.collect_max_evaluation_summaries
         )
@@ -382,9 +383,7 @@ module Quonfig
     # Initialize network mode: sync HTTP fetch (bounded by
     # initialization_timeout_sec) then start SSE + polling as requested.
     def initialize_network_mode
-      if @options.sdk_key.nil? || @options.sdk_key.to_s.strip.empty?
-        raise Quonfig::Errors::InvalidSdkKeyError, @options.sdk_key
-      end
+      raise Quonfig::Errors::InvalidSdkKeyError, @options.sdk_key if @options.sdk_key.nil? || @options.sdk_key.to_s.strip.empty?
 
       @config_loader = Quonfig::ConfigLoader.new(@store, @options)
 
@@ -433,6 +432,7 @@ module Quonfig
       @sse_client = Quonfig::SSEConfigClient.new(@options, @config_loader)
       @sse_client.start do |envelope, _event, _source|
         next if @stopped
+
         begin
           @config_loader.apply_envelope(envelope)
           @on_update&.call
@@ -455,6 +455,7 @@ module Quonfig
         Thread.current.name = 'quonfig-poller'
         loop do
           break if @stopped
+
           sleep poll_interval
           break if @stopped
 
@@ -505,11 +506,11 @@ module Quonfig
       merged = {}
       left.each  { |name, ctx| merged[name] = ctx.is_a?(Hash) ? ctx.dup : ctx }
       right.each do |name, ctx|
-        if merged[name].is_a?(Hash) && ctx.is_a?(Hash)
-          merged[name] = merged[name].merge(ctx)
-        else
-          merged[name] = ctx.is_a?(Hash) ? ctx.dup : ctx
-        end
+        merged[name] = if merged[name].is_a?(Hash) && ctx.is_a?(Hash)
+                         merged[name].merge(ctx)
+                       else
+                         ctx.is_a?(Hash) ? ctx.dup : ctx
+                       end
       end
       merged
     end
@@ -525,9 +526,7 @@ module Quonfig
     def handle_missing(key, default)
       return default if default != NO_DEFAULT_PROVIDED
 
-      if @options.on_no_default == Quonfig::Options::ON_NO_DEFAULT::RAISE
-        raise Quonfig::Errors::MissingDefaultError, key
-      end
+      raise Quonfig::Errors::MissingDefaultError, key if @options.on_no_default == Quonfig::Options::ON_NO_DEFAULT::RAISE
 
       nil
     end
@@ -602,29 +601,25 @@ module Quonfig
     def coerce_and_check(key, value, expected_type)
       case expected_type
       when :bool
-        unless value == true || value == false
-          raise Quonfig::Errors::TypeMismatchError.new(key, 'Boolean', value)
-        end
+        raise Quonfig::Errors::TypeMismatchError.new(key, 'Boolean', value) unless [true, false].include?(value)
+
         value
       when :string_list
         arr = value.is_a?(Array) ? value : nil
-        unless arr && arr.all? { |v| v.is_a?(String) }
-          raise Quonfig::Errors::TypeMismatchError.new(key, 'Array<String>', value)
-        end
+        raise Quonfig::Errors::TypeMismatchError.new(key, 'Array<String>', value) unless arr&.all?(String)
+
         arr
       when :duration
         return value.to_i if value.is_a?(Numeric)
-        if value.is_a?(String)
-          return (Quonfig::Duration.parse(value) * 1000).to_i
-        end
+        return (Quonfig::Duration.parse(value) * 1000).to_i if value.is_a?(String)
+
         raise Quonfig::Errors::TypeMismatchError.new(key, 'ISO-8601 Duration', value)
       when :json
         # JSON values are returned as-is (Hash, Array, or scalar from the wire).
         value
       when Class
-        unless value.is_a?(expected_type)
-          raise Quonfig::Errors::TypeMismatchError.new(key, "expected #{expected_type}", value)
-        end
+        raise Quonfig::Errors::TypeMismatchError.new(key, "expected #{expected_type}", value) unless value.is_a?(expected_type)
+
         value
       else
         value

data/lib/quonfig/config_loader.rb

@@ -124,8 +124,9 @@ module Quonfig
 
     def short_body(response)
       return '' if response.body.nil?
+
       str = response.body.to_s
-      str.length > 200 ? str[0, 200] + '...' : str
+      str.length > 200 ? "#{str[0, 200]}..." : str
     end
 
     def install_envelope(envelope, source:)
@@ -134,6 +135,7 @@ module Quonfig
       envelope.configs.each do |cfg|
         key = config_key(cfg)
         next if key.nil?
+
         next_map[key] = { source: source, config: cfg }
       end
       @api_config = next_map
@@ -153,12 +155,14 @@ module Quonfig
       envelope.configs.each do |cfg|
         key = config_key(cfg)
         next if key.nil?
+
         @store.set(key, cfg)
       end
     end
 
     def config_key(cfg)
       return cfg['key'] || cfg[:key] if cfg.is_a?(Hash)
+
       cfg.respond_to?(:key) ? cfg.key : nil
     end
   end

data/lib/quonfig/config_store.rb

@@ -6,9 +6,15 @@ module Quonfig
   # Mirrors sdk-node's ConfigStore (src/store.ts). Integration tests and the
   # new Resolver/Evaluator trio construct this directly, independent of any
   # Client/ConfigLoader plumbing.
+  #
+  # Thread-safety: backed by Concurrent::Map, whose per-key reads, writes, and
+  # deletes are atomic. There is no compound multi-key operation here that
+  # needs an outer lock — envelope application in ConfigLoader is a sequence
+  # of independent set/delete calls, and readers tolerate seeing the
+  # in-progress mix. Eventual consistency across an envelope is acceptable
+  # and matches sdk-node behavior.
   class ConfigStore
     def initialize(initial_configs = nil)
-      @lock = Concurrent::ReadWriteLock.new
       @configs = Concurrent::Map.new
       return unless initial_configs
 
@@ -20,17 +26,15 @@ module Quonfig
     end
 
     def set(key, config)
-      @lock.with_write_lock { @configs[key] = config }
+      @configs[key] = config
     end
 
     def delete(key)
-      @lock.with_write_lock { @configs.delete(key) }
+      @configs.delete(key)
     end
 
     def clear
-      @lock.with_write_lock do
-        @configs.keys.each { |k| @configs.delete(k) }
-      end
+      @configs.each_key { |k| @configs.delete(k) }
     end
 
     def keys

data/lib/quonfig/context.rb

@@ -47,7 +47,7 @@ module Quonfig
 
         @contexts[name.to_s] = NamedContext.new(name, values)
         values.each do |key, value|
-          @flattened[name.to_s + '.' + key.to_s] = value
+          @flattened["#{name}.#{key}"] = value
         end
       end
     end
@@ -59,12 +59,12 @@ module Quonfig
     def set(name, hash)
       @contexts[name.to_s] = NamedContext.new(name, hash)
       hash.each do |key, value|
-        @flattened[name.to_s + '.' + key.to_s] = value
+        @flattened["#{name}.#{key}"] = value
       end
     end
 
     def get(property_key, scope: nil)
-      property_key = BLANK_CONTEXT_NAME + '.' + property_key unless property_key.include?('.')
+      property_key = "#{BLANK_CONTEXT_NAME}.#{property_key}" unless property_key.include?('.')
       @flattened[property_key]
     end
 
@@ -94,11 +94,12 @@ module Quonfig
       @contexts.values.map do |ctx|
         h = ctx.to_h
         v = h['key'] || h[:key] || h['trackingId'] || h[:trackingId]
-        v.nil? ? nil : v.to_s
+        v&.to_s
       end.compact.reject(&:empty?).sort.join('|')
     end
 
     include Comparable
+
     def <=>(other)
       if other.is_a?(Quonfig::Context)
         to_h <=> other.to_h

data/lib/quonfig/datadir.rb

@@ -56,21 +56,15 @@ module Quonfig
     end
 
     def resolve_environment(quonfig_path, environment)
-      environment ||= ENV['QUONFIG_ENVIRONMENT']
+      environment ||= ENV.fetch('QUONFIG_ENVIRONMENT', nil)
 
-      if environment.nil? || environment.empty?
-        raise Quonfig::Errors::MissingEnvironmentError
-      end
+      raise Quonfig::Errors::MissingEnvironmentError if environment.nil? || environment.empty?
 
-      unless File.exist?(quonfig_path)
-        raise ArgumentError, "[quonfig] Datadir is missing quonfig.json: #{quonfig_path}"
-      end
+      raise ArgumentError, "[quonfig] Datadir is missing quonfig.json: #{quonfig_path}" unless File.exist?(quonfig_path)
 
       environments = JSON.parse(File.read(quonfig_path)).fetch('environments', [])
 
-      if !environments.empty? && !environments.include?(environment)
-        raise Quonfig::Errors::InvalidEnvironmentError.new(environment, environments)
-      end
+      raise Quonfig::Errors::InvalidEnvironmentError.new(environment, environments) if !environments.empty? && !environments.include?(environment)
 
       environment
     end

data/lib/quonfig/dev_context.rb

@@ -12,6 +12,8 @@ module Quonfig
   # run `qfg login` and therefore have no tokens file. Rules keyed on
   # `quonfig-user.email` are dead code in prod.
   module DevContext
+    LOG = Quonfig::InternalLogger.new(self)
+
     TOKENS_BASENAME = File.join('.quonfig', 'tokens.json')
 
     def self.load_quonfig_user_context
@@ -21,14 +23,14 @@ module Quonfig
       raw = begin
         File.read(path)
       rescue StandardError => e
-        warn "[quonfig] dev-context: could not read #{path} (#{e.class}: #{e.message}); skipping injection"
+        LOG.warn "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"
+        LOG.warn "dev-context: could not parse #{path} (#{e.message}); skipping injection"
         return nil
       end
 

data/lib/quonfig/duration.rb

@@ -20,7 +20,7 @@ module Quonfig
       minutes = match[:minutes]&.to_f || 0
       seconds = match[:seconds]&.to_f || 0
 
-      (days * DAYS_IN_SECONDS + hours * HOURS_IN_SECONDS + minutes * MINUTES_IN_SECONDS + seconds)
+      ((days * DAYS_IN_SECONDS) + (hours * HOURS_IN_SECONDS) + (minutes * MINUTES_IN_SECONDS) + seconds)
     end
 
     def in_seconds
@@ -52,7 +52,7 @@ module Quonfig
     end
 
     def as_json
-      { ms:  in_seconds * 1000, seconds: in_seconds }
+      { ms: in_seconds * 1000, seconds: in_seconds }
     end
   end
 end

data/lib/quonfig/encryption.rb

@@ -2,8 +2,8 @@
 
 module Quonfig
   class Encryption
-    CIPHER_TYPE = "aes-256-gcm" # 32/12
-    SEPARATOR = "--"
+    CIPHER_TYPE = 'aes-256-gcm' # 32/12
+    SEPARATOR = '--'
     AUTH_TAG_LENGTH = 16
 
     # Hexadecimal format ensures that generated keys are representable with
@@ -12,11 +12,11 @@ module Quonfig
     # To convert back to the original string with the desired length:
     #   [ value ].pack("H*")
     def self.generate_new_hex_key
-      generate_random_key.unpack("H*")[0]
+      generate_random_key.unpack1('H*')
     end
 
     def initialize(key_string_hex)
-      @key = [key_string_hex].pack("H*")
+      @key = [key_string_hex].pack('H*')
     end
 
     def encrypt(clear_text)
@@ -27,42 +27,38 @@ module Quonfig
       # load them into the cipher
       cipher.key = @key
       cipher.iv = iv
-      cipher.auth_data = ""
+      cipher.auth_data = ''
 
       # encrypt the message
       encrypted = cipher.update(clear_text)
       encrypted << cipher.final
       tag = cipher.auth_tag
-      
+
       # pack and join
-      [encrypted, iv, tag].map { |p| p.unpack("H*")[0] }.join(SEPARATOR)
+      [encrypted, iv, tag].map { |p| p.unpack1('H*') }.join(SEPARATOR)
     end
 
     def decrypt(encrypted_string)
-      encrypted_data, iv, auth_tag = encrypted_string.split(SEPARATOR).map { |p| [p].pack("H*") }
-      
+      encrypted_data, iv, auth_tag = encrypted_string.split(SEPARATOR).map { |p| [p].pack('H*') }
+
       # Currently the OpenSSL bindings do not raise an error if auth_tag is
       # truncated, which would allow an attacker to easily forge it. See
       # https://github.com/ruby/openssl/issues/63
-      if auth_tag.bytesize != AUTH_TAG_LENGTH
-        raise "truncated auth_tag"
-      end
+      raise 'truncated auth_tag' if auth_tag.bytesize != AUTH_TAG_LENGTH
 
       cipher = OpenSSL::Cipher.new(CIPHER_TYPE)
       cipher.decrypt
       cipher.key = @key
       cipher.iv = iv
-  
+
       cipher.auth_tag = auth_tag
-     
+
       # and decrypt it
       decrypted = cipher.update(encrypted_data)
       decrypted << cipher.final
       decrypted
     end
 
-    private
-
     def self.generate_random_key
       SecureRandom.random_bytes(key_length)
     end

data/lib/quonfig/errors/invalid_environment_error.rb

@@ -9,9 +9,7 @@ module Quonfig
     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
+        message += "; available environments: #{Array(available).join(', ')}" if available && !Array(available).empty?
         super(message)
       end
     end

data/lib/quonfig/errors/invalid_sdk_key_error.rb

@@ -4,15 +4,14 @@ module Quonfig
   module Errors
     class InvalidSdkKeyError < Quonfig::Error
       def initialize(key)
-        if key.nil? || key.empty?
-          message = 'No SDK key. Set QUONFIG_BACKEND_SDK_KEY env var or use QUONFIG_DATAFILE'
+        message = if key.nil? || key.empty?
+                    'No SDK key. Set QUONFIG_BACKEND_SDK_KEY env var or use QUONFIG_DATAFILE'
 
-          super(message)
-        else
-          message = "Your SDK key format is invalid. Expecting something like 123-development-yourapikey-SDK. You provided `#{key}`"
+                  else
+                    "Your SDK key format is invalid. Expecting something like 123-development-yourapikey-SDK. You provided `#{key}`"
 
-          super(message)
-        end
+                  end
+        super(message)
       end
     end
   end

data/lib/quonfig/errors/missing_env_var_error.rb

@@ -3,9 +3,6 @@
 module Quonfig
   module Errors
     class MissingEnvVarError < Quonfig::Error
-      def initialize(message)
-        super(message)
-      end
     end
   end
 end

data/lib/quonfig/errors/missing_environment_error.rb

@@ -11,7 +11,7 @@ module Quonfig
       def initialize(message = nil)
         message ||= '[quonfig] Environment required for datadir mode; ' \
                     'set the `environment` option or QUONFIG_ENVIRONMENT env var'
-        super(message)
+        super
       end
     end
   end

data/lib/quonfig/errors/uninitialized_error.rb

@@ -3,7 +3,7 @@
 module Quonfig
   module Errors
     class UninitializedError < Quonfig::Error
-      def initialize(key=nil)
+      def initialize(key = nil)
         message = "Use Quonfig.initialize before calling Quonfig.get #{key}"
 
         super(message)