quonfig 1.4.1 → 1.6.0

data/lib/quonfig/resolver.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'digest'
+require 'set'
 
 module Quonfig
   # Public-API resolver: looks up a config by key in a ConfigStore and runs
@@ -16,6 +17,7 @@ module Quonfig
   # production read path (with config_loader, SSE updates, telemetry), see
   # Quonfig::ConfigResolver — the two coexist during the JSON migration.
   class Resolver
+    LOG = Quonfig::InternalLogger.new(self)
     TRUE_VALUES = %w[true 1 t yes].freeze
     # Prefix the eval-summary aggregator stamps onto redacted confidential
     # values before the 5-char MD5 hash. Matches CONFIDENTIAL_PREFIX in
@@ -29,6 +31,9 @@ module Quonfig
     def initialize(store, evaluator)
       @store = store
       @evaluator = evaluator
+      # Config keys already warned about a missing hash property (qfg-9dxb.8).
+      @hash_missing_warned = Set.new
+      @hash_missing_mutex = Mutex.new
     end
 
     def raw(key)
@@ -50,7 +55,8 @@ module Quonfig
       return nil if eval_result.nil?
 
       weighted_index = nil
-      resolved_value = resolve_value(eval_result.value, config, context) do |idx|
+      hash_missing = []
+      resolved_value = resolve_value_on_path(eval_result.value, config, context, [], hash_missing) do |idx|
         weighted_index = idx
       end
       EvalResult.new(
@@ -58,7 +64,8 @@ module Quonfig
         rule_index: eval_result.rule_index,
         config: config,
         weighted_value_index: weighted_index,
-        reportable_value: redacted_reportable_value(eval_result.value)
+        reportable_value: redacted_reportable_value(eval_result.value),
+        hash_property_missing: !hash_missing.empty?
       )
     end
 
@@ -68,32 +75,42 @@ module Quonfig
     # - confidential + decryptWith → look up the key config, decrypt
     # - everything else passes through unchanged
     def resolve_value(value, config, context = nil, &on_weighted_index)
+      resolve_value_on_path(value, config, context, [], &on_weighted_index)
+    end
+
+    # Integration shims for code that expects a ConfigResolver. Keep these
+    # narrow; the real ConfigResolver still owns the production hot path.
+    def symbolize_json_names?
+      false
+    end
+
+    private
+
+    # resolve_value plus +key_path+: the config keys already being resolved
+    # above this one through decryptWith, so a decryptWith cycle raises a
+    # DecryptionError instead of recursing until SystemStackError
+    # (qfg-9dxb.7, matching sdk-go qfg-9dxb.4). +hash_missing+, when given,
+    # gets an entry for each weighted rollout whose hash property was missing
+    # from the context (qfg-9dxb.8).
+    def resolve_value_on_path(value, config, context, key_path, hash_missing = nil, &on_weighted_index)
       return nil if value.nil?
 
       type = vget(value, :type, 'type')
 
       return resolve_provided(value, config) if type == 'provided'
 
-      return resolve_weighted(value, config, context, &on_weighted_index) if type == 'weighted_values'
+      return resolve_weighted(value, config, context, key_path, hash_missing, &on_weighted_index) if type == 'weighted_values'
 
       confidential = vget(value, :confidential, 'confidential')
       decrypt_with = vget(value, :decryptWith, 'decryptWith', :decrypt_with, 'decrypt_with')
       if confidential && decrypt_with && !decrypt_with.to_s.empty?
         return resolve_decryption(value, config, context,
-                                  decrypt_with)
+                                  decrypt_with, key_path)
       end
 
       value
     end
 
-    # Integration shims for code that expects a ConfigResolver. Keep these
-    # narrow; the real ConfigResolver still owns the production hot path.
-    def symbolize_json_names?
-      false
-    end
-
-    private
-
     # If +value+ is confidential or has a decryptWith key, return the
     # `*****<5-hex>` redacted string the eval-summary telemetry aggregator
     # should ship in place of the resolved plaintext. The hash is computed
@@ -162,7 +179,12 @@ module Quonfig
     # (or fall back to a per-call random) into [0,1), then walk the variant
     # weights until cumulative weight >= bucket. Recurses through
     # resolve_value so nested provided/encrypted variants work too.
-    def resolve_weighted(value, config, context, &on_weighted_index)
+    #
+    # A hash property that is configured but missing from the context (or
+    # nil) hashes an empty value, the same bucket as a present "", and warns
+    # once per config key (qfg-9dxb.8). With no hash property configured the
+    # pick stays random per call.
+    def resolve_weighted(value, config, context, key_path, hash_missing = nil, &on_weighted_index)
       payload = vget(value, :value, 'value') || {}
       weighted = vget(payload, :weightedValues, 'weightedValues', :weighted_values, 'weighted_values')
       return value unless weighted.is_a?(Array) && !weighted.empty?
@@ -182,23 +204,42 @@ module Quonfig
       end
 
       cfg_key = config_key(config)
+      if hash_value.nil? && !hash_property.to_s.empty?
+        hash_value = ''
+        hash_missing&.push(true)
+        warn_hash_property_missing(cfg_key, hash_property)
+      end
       picker = Quonfig::WeightedValueResolver.new(weighted, cfg_key, hash_value)
       variant, index = picker.resolve
       on_weighted_index&.call(index)
       variant_value = vget(variant, :value, 'value')
-      resolve_value(variant_value, config, context, &on_weighted_index)
+      resolve_value_on_path(variant_value, config, context, key_path, hash_missing, &on_weighted_index)
+    end
+
+    def warn_hash_property_missing(cfg_key, hash_property)
+      return unless @hash_missing_mutex.synchronize { @hash_missing_warned.add?(cfg_key) }
+
+      LOG.warn "quonfig: weighted rollout for \"#{cfg_key}\" hashes on \"#{hash_property}\" " \
+               'which is missing from context; hashing an empty value instead'
     end
 
     # Recursively resolve the decryption-key config (it may itself be a
     # provided ENV_VAR), then AES-GCM decrypt the value with that key.
-    def resolve_decryption(value, config, context, decrypt_with)
+    def resolve_decryption(value, config, context, decrypt_with, key_path)
+      key_path += [config_key(config).to_s]
+      if key_path.include?(decrypt_with.to_s)
+        raise Quonfig::Errors::DecryptionError.new(
+          config_key(config), %(decryption key config "#{decrypt_with}" is part of a decryptWith cycle)
+        )
+      end
+
       key_cfg = @store.get(decrypt_with)
       raise Quonfig::Error, %(Decryption key config "#{decrypt_with}" not found) if key_cfg.nil?
 
       key_match = @evaluator.evaluate_config(key_cfg, context, resolver: self)
       raise Quonfig::Error, %(Decryption key config "#{decrypt_with}" did not match) if key_match.nil?
 
-      resolved_key = resolve_value(key_match.value, key_cfg, context)
+      resolved_key = resolve_value_on_path(key_match.value, key_cfg, context, key_path)
       secret_key = vget(resolved_key, :value, 'value').to_s
       raise Quonfig::Error, %(Decryption key from "#{decrypt_with}" is empty) if secret_key.empty?
 

data/lib/quonfig/sse_config_client.rb

@@ -604,6 +604,14 @@ module Quonfig
           return nil
         end
 
+        # qfg-9dxb.3: drop a JSON event that is not a config envelope (no meta
+        # object with a non-empty version) exactly like malformed JSON — it must
+        # never reach install and wipe an established client's keys.
+        unless Quonfig::ConfigEnvelope.wire_envelope?(parsed)
+          (@logger || LOG).error 'SSE Streaming Error: non-envelope event (missing meta.version); dropped'
+          return nil
+        end
+
         envelope = Quonfig::ConfigEnvelope.new(
           configs: parsed['configs'] || [],
           meta: parsed['meta'] || {}

data/lib/quonfig/telemetry/example_contexts_aggregator.rb

@@ -10,11 +10,16 @@ module Quonfig
     # matching sdk-node and sdk-go. This is NOT the old Prefab protobuf.
     class ExampleContextsAggregator
       ONE_HOUR_SECONDS = 60 * 60
+      # Bound on the once-per-hour rate-limit map (P6 of the telemetry
+      # transport policy, qfg-y8je.8): a new key arriving when it is full
+      # prunes expired entries, and is not recorded if it is still full.
+      SEEN_CAP = 100_000
 
       attr_reader :data, :cache
 
-      def initialize(max_contexts:, rate_limit_seconds: ONE_HOUR_SECONDS)
+      def initialize(max_contexts:, rate_limit_seconds: ONE_HOUR_SECONDS, seen_cap: SEEN_CAP)
         @max_contexts = max_contexts
+        @seen_cap = seen_cap
         @data = Concurrent::Array.new
         @cache = Quonfig::RateLimitCache.new(rate_limit_seconds)
       end
@@ -30,6 +35,7 @@ module Quonfig
         return if key.nil? || key.empty?
 
         return unless @data.size < @max_contexts && !@cache.fresh?(key)
+        return unless room_in_cache?
 
         @cache.set(key)
         @data.push([Quonfig::TimeHelpers.now_in_ms, context])
@@ -59,6 +65,13 @@ module Quonfig
 
       private
 
+      def room_in_cache?
+        return true if @cache.data.size < @seen_cap
+
+        @cache.prune
+        @cache.data.size < @seen_cap
+      end
+
       def grouped_key_for(context)
         return context.grouped_key if context.respond_to?(:grouped_key)
 

data/lib/quonfig/telemetry/telemetry_reporter.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module Quonfig
   module Telemetry
-    # Owns the background thread that periodically drains the context
-    # aggregators and POSTs a JSON telemetry batch to
-    # +<telemetry_destination>/api/v1/telemetry/+.
+    # Owns the background thread that drains the aggregators once per tick and
+    # hands the serialized window to a TransportQueue, which retains failed
+    # batches byte-for-byte and resends them under the telemetry transport
+    # policy (qfg-y8je.8: 60s ticks, one POST in flight, 15s timeout / 5s
+    # connect, 30s floor after a failure, Retry-After up to 10 min,
+    # 5 batches / 2MB / 5 min retention, disable on 401/403/404; see
+    # TransportQueue).
     #
     # Wire shape matches api-telemetry's TelemetryEventsSchema:
     #
@@ -24,16 +30,47 @@ module Quonfig
     class TelemetryReporter
       LOG = Quonfig::InternalLogger.new(self)
 
-      DEFAULT_INITIAL_DELAY_SECONDS = 8
-      DEFAULT_MAX_DELAY_SECONDS = 600
+      TELEMETRY_PATH = '/api/v1/telemetry/'
+      BODY_SNIPPET_BYTES = 1024
+      private_constant :BODY_SNIPPET_BYTES
+
+      # Build the aggregators the options enable and a reporter over them, or
+      # nil when every collector is off. Client#initialize_telemetry uses this;
+      # +clock+ is a test seam (defaults to the monotonic clock).
+      def self.build(options:, instance_hash:, failover_aggregator: nil, clock: nil)
+        shapes = (ContextShapeAggregator.new(max_shapes: options.collect_max_shapes) if options.collect_max_shapes.to_i.positive?)
+        examples = (ExampleContextsAggregator.new(max_contexts: options.collect_max_example_contexts) if options.collect_max_example_contexts.to_i.positive?)
+        summaries = (EvaluationSummariesAggregator.new(max_keys: options.collect_max_evaluation_summaries) if options.collect_max_evaluation_summaries.to_i.positive?)
+        return nil if shapes.nil? && examples.nil? && summaries.nil?
+
+        new(
+          options: options,
+          instance_hash: instance_hash,
+          context_shape_aggregator: shapes,
+          example_contexts_aggregator: examples,
+          evaluation_summaries_aggregator: summaries,
+          failover_aggregator: failover_aggregator,
+          clock: clock
+        )
+      end
+
+      # Resolved transport settings (the +telemetry_*+ options and
+      # +collect_sync_interval+). +flush_interval_ms+ is nil when the interval
+      # is a callable.
+      attr_reader :config
 
+      # +sync_interval+ (seconds, or a callable returning seconds) defaults to
+      # +options.collect_sync_interval+ (60). +http_connection+ is a test seam:
+      # anything answering +post(path, body_string)+ with a response that has
+      # +status+.
       def initialize(options:, instance_hash:,
                      context_shape_aggregator: nil,
                      example_contexts_aggregator: nil,
                      evaluation_summaries_aggregator: nil,
                      failover_aggregator: nil,
                      sync_interval: nil,
-                     http_connection: nil)
+                     http_connection: nil,
+                     clock: nil)
         @options = options
         @instance_hash = instance_hash
         @sdk_key = options.sdk_key
@@ -47,8 +84,31 @@ module Quonfig
         # aggregator at the failover call sites; the reporter only drains it.
         @failover_aggregator = failover_aggregator
         @http_connection = http_connection
-        @sync_interval = calculate_sync_interval(sync_interval)
-        @stopped = Concurrent::AtomicBoolean.new(false)
+        @sync_interval = sync_interval.nil? ? options.collect_sync_interval : sync_interval
+        @config = {
+          flush_interval_ms: @sync_interval.is_a?(Numeric) ? (@sync_interval * 1000).to_i : nil,
+          timeout_ms: options.telemetry_timeout_ms,
+          connect_timeout_ms: options.telemetry_connect_timeout_ms,
+          max_retained_batches: options.telemetry_max_retained_batches,
+          max_retained_bytes: options.telemetry_max_retained_bytes,
+          max_retained_age_ms: options.telemetry_max_retained_age_ms
+        }.freeze
+        @queue = TransportQueue.new(
+          sender: method(:post_batch),
+          telemetry_url: "#{@telemetry_destination}#{TELEMETRY_PATH}",
+          timeout_ms: @config[:timeout_ms],
+          max_retained_batches: @config[:max_retained_batches],
+          max_retained_bytes: @config[:max_retained_bytes],
+          max_retained_age_ms: @config[:max_retained_age_ms],
+          clock: clock || MonotonicClock,
+          on_disabled: method(:on_disabled)
+        )
+        # Held for a whole tick (serialize + drain), so at most one POST is in
+        # flight (P2); a tick that finds it held is skipped.
+        @tick_mutex = Mutex.new
+        @state_mutex = Mutex.new
+        @wake = ConditionVariable.new
+        @closed = false
         @thread = nil
         @at_exit_registered = false
         # Set on #start. Everything that can EMIT is gated on it so a forked
@@ -69,97 +129,104 @@ module Quonfig
       # summaries are recorded separately via
       # +record_evaluation(...)+ since they require the evaluation result.
       def record(context)
-        return if context.nil?
+        return if context.nil? || @queue.disabled?
 
         @context_shape_aggregator&.push(context)
         @example_contexts_aggregator&.record(context)
       end
 
       def record_evaluation(**kwargs)
+        return if @queue.disabled?
+
         @evaluation_summaries_aggregator&.record(**kwargs)
       end
 
       def start
         return if @thread&.alive?
         return unless enabled?
+        return if @closed || @queue.disabled?
 
         # Claim ownership for THIS process. fork(2) copies the reporter, its
         # aggregators, and the process-wide at_exit closure registered below;
         # the pid recorded here is what lets the copy know it is not the
         # owner and must stay silent (qfg-lv4n.1, dd-trace-rb's pattern).
         @owner_pid = Process.pid
-        @stopped.make_false
         register_at_exit_handler
         @thread = Thread.new do
           Thread.current.name = 'quonfig-telemetry-reporter'
           LOG.debug "Telemetry reporter started instance_hash=#{@instance_hash} destination=#{@telemetry_destination}"
-
-          until @stopped.true?
-            begin
-              sleep_duration = @sync_interval.call
-              slept = 0.0
-              step = 0.5
-              while slept < sleep_duration && !@stopped.true?
-                sleep([step, sleep_duration - slept].min)
-                slept += step
-              end
-              break if @stopped.true?
-
-              sync
-            rescue StandardError => e
-              LOG.warn "[quonfig] Telemetry reporter error: #{e.class}: #{e.message}"
-            end
-          end
+          run_loop
         end
       end
 
-      def stop
-        return if foreign_process?('stop')
+      # One tick of the contract's model: skip if closed, disabled or a POST is
+      # in flight (P2; the live window keeps aggregating); expire aged batches;
+      # skip if the 30s floor or Retry-After has not elapsed; serialize the
+      # live window once and append it; drain oldest-first.
+      def tick
+        return if foreign_process?('tick')
+        return unless @tick_mutex.try_lock
 
-        @stopped.make_true
-        thread = @thread
-        @thread = nil
-        thread&.wakeup if thread&.alive?
-        # Final drain attempt on stop so tests / short-lived processes
-        # don't silently drop pending telemetry.
         begin
-          sync
-        rescue StandardError => e
-          LOG.debug "[quonfig] Final telemetry sync failed: #{e.class}: #{e.message}"
+          run_tick
+        ensure
+          @tick_mutex.unlock
         end
       end
 
-      # Drain all aggregators and POST the batch. Public so tests can
-      # trigger a sync without waiting for the background loop.
+      # Send the live window now. Waits for an in-flight POST first (bounded by
+      # the request timeout), then runs a tick, so after a failure it respects
+      # the 30s floor and Retry-After. Never raises.
       #
       # Silent in any process other than the one that started the reporter:
       # after a fork the child holds a full copy of the PARENT's un-flushed
       # window, and the parent is still going to flush it itself.
-      def sync
+      def flush
         return if foreign_process?('sync')
 
-        events = []
-        if (summaries_event = @evaluation_summaries_aggregator&.drain_event)
-          events << summaries_event
-        end
-        if (shape_event = @context_shape_aggregator&.drain_event)
-          events << shape_event
-        end
-        if (example_event = @example_contexts_aggregator&.drain_event)
-          events << example_event
-        end
-        if (failover_event = @failover_aggregator&.drain_event)
-          events << failover_event
+        @tick_mutex.synchronize { run_tick }
+      rescue StandardError => e
+        LOG.debug "Telemetry flush failed: #{e.class}: #{e.message}"
+      end
+      alias sync flush
+
+      # Shutdown (P8): stop the reporter thread (aborting an in-flight POST),
+      # then give the live window one POST with a 5s deadline. The retained
+      # queue is not drained. Idempotent; never raises; never blocks exit for
+      # longer than that deadline.
+      def close
+        return if foreign_process?('close')
+
+        thread = @state_mutex.synchronize do
+          return if @closed
+
+          @closed = true
+          current = @thread
+          @thread = nil
+          current
         end
+        stop_thread(thread)
+        return if @queue.disabled?
 
-        return if events.empty?
+        body = serialize_window
+        return if body.nil?
 
-        payload = {
-          'instanceHash' => @instance_hash,
-          'events' => events
+        @queue.send_final(body, [TransportQueue::SHUTDOWN_FLUSH_DEADLINE_MS, @config[:timeout_ms]].min)
+      rescue StandardError => e
+        LOG.debug "Telemetry close failed: #{e.class}: #{e.message}"
+      end
+      alias stop close
+
+      # Test-visible state (the contract's retained_count / retained_bytes /
+      # telemetry_enabled).
+      def debug_state
+        {
+          retained_count: @queue.retained_count,
+          retained_bytes: @queue.retained_bytes,
+          enabled: !@queue.disabled?,
+          in_flight: @queue.in_flight?,
+          thread_alive: @thread&.alive? || false
         }
-
-        post(payload)
       end
 
       # Visible for tests.
@@ -180,7 +247,7 @@ module Quonfig
       # not exist in the child, and the HTTP connection's fd is shared with
       # the parent.
       def discard_inherited!
-        @stopped.make_true
+        @closed = true
         @thread = nil
         @context_shape_aggregator = nil
         @example_contexts_aggregator = nil
@@ -190,6 +257,106 @@ module Quonfig
 
       private
 
+      def run_tick
+        return if @closed || @queue.disabled?
+
+        @queue.expire
+        return unless @queue.send_allowed?
+
+        body = serialize_window
+        @queue.append(body) if body
+        @queue.drain
+      end
+
+      # Fixed cadence: tick k fires at k * interval regardless of how long a
+      # drain takes. The interval never grows (the old exponential backoff,
+      # which grew even on success, is gone: P4).
+      def run_loop
+        next_at = MonotonicClock.now_ms + next_interval_ms
+        until loop_done?
+          wait_ms = next_at - MonotonicClock.now_ms
+          if wait_ms.positive?
+            @state_mutex.synchronize { @wake.wait(@state_mutex, wait_ms / 1000.0) unless loop_done? }
+            next
+          end
+          next_at += next_interval_ms
+          next_at = MonotonicClock.now_ms + next_interval_ms if next_at <= MonotonicClock.now_ms
+          begin
+            tick
+          rescue StandardError => e
+            LOG.debug "Telemetry tick failed: #{e.class}: #{e.message}"
+          end
+        end
+      end
+
+      def loop_done?
+        @closed || @queue.disabled?
+      end
+
+      def next_interval_ms
+        seconds = @sync_interval.respond_to?(:call) ? @sync_interval.call : @sync_interval
+        [(seconds.to_f * 1000).to_i, 1].max
+      end
+
+      def wake_thread
+        @state_mutex.synchronize { @wake.broadcast }
+      end
+
+      # Stop the reporter thread. A thread parked in its wait exits on the
+      # broadcast; one still busy (a POST in flight) is killed, which aborts
+      # the POST like sdk-node's close() does. The aborted batch is never resent.
+      def stop_thread(thread)
+        return if thread.nil? || thread == Thread.current || !thread.alive?
+
+        wake_thread
+        thread.kill unless thread.join(0.1)
+      end
+
+      def on_disabled
+        # Nothing aggregates for a dead endpoint: drop what the window holds.
+        serialize_window
+        wake_thread
+      end
+
+      # Drain the aggregators into one serialized payload. This is the only
+      # serialization: the queue stores and resends these exact bytes (P5, P9).
+      def serialize_window
+        events = [
+          @evaluation_summaries_aggregator&.drain_event,
+          @context_shape_aggregator&.drain_event,
+          @example_contexts_aggregator&.drain_event,
+          # nil unless the window saw failover activity.
+          @failover_aggregator&.drain_event
+        ].compact
+        return nil if events.empty?
+
+        JSON.generate('instanceHash' => @instance_hash, 'events' => events)
+      end
+
+      # The TransportQueue sender: one POST of +body+ verbatim.
+      def post_batch(body, timeout_ms)
+        response = telemetry_connection(timeout_ms).post(TELEMETRY_PATH, body)
+        headers = response.respond_to?(:headers) ? response.headers : nil
+        snippet = response.respond_to?(:body) ? response.body.to_s.byteslice(0, BODY_SNIPPET_BYTES) : ''
+        TransportQueue::Result.new(
+          status: response.status.to_i,
+          retry_after: headers && headers['retry-after'],
+          body_snippet: snippet
+        )
+      end
+
+      # A connection bounded by +timeout_ms+ overall and the connect timeout
+      # (never longer than +timeout_ms+) for TCP connect + TLS (P1).
+      def telemetry_connection(timeout_ms)
+        return @http_connection if @http_connection
+
+        Quonfig::HttpConnection.new(
+          @telemetry_destination, @sdk_key,
+          timeout_ms: timeout_ms,
+          open_timeout_ms: [@config[:connect_timeout_ms], timeout_ms].min
+        )
+      end
+
       # True when this reporter belongs to a different process — i.e. we are
       # a fork(2) copy. Never true before #start (nothing has been claimed,
       # and nothing was registered at_exit either).
@@ -204,7 +371,7 @@ module Quonfig
 
       # Rails / Passenger / Puma workers often terminate via SIGTERM without
       # a chance to call Client#stop. Register a Kernel.at_exit hook on
-      # first start so the in-flight batch still gets flushed.
+      # first start so the live window still gets its one final flush.
       def register_at_exit_handler
         return if @at_exit_registered
 
@@ -212,62 +379,11 @@ module Quonfig
         @at_exit_registered = true
       end
 
-      # Wait this long for the background reporter thread to exit before
-      # giving up. Bounded so a thread blocked on a dead telemetry endpoint
-      # can't hang process exit.
-      AT_EXIT_THREAD_JOIN_TIMEOUT_SECONDS = 1.0
-      private_constant :AT_EXIT_THREAD_JOIN_TIMEOUT_SECONDS
-
-      # Idempotent final drain. Safe to call after #stop has already
-      # drained: aggregators return nil when empty and #sync becomes a
-      # no-op. Bounded so a stuck reporter thread or dead telemetry
+      # Idempotent final flush (#close). Safe after #stop: a second close is a
+      # no-op. Bounded by the 5s shutdown deadline, so a dead telemetry
       # endpoint can't hang process exit.
       def final_drain_on_exit
-        return if foreign_process?('at_exit drain')
-
-        @stopped.make_true
-        thread = @thread
-        @thread = nil
-        if thread&.alive?
-          thread.wakeup
-          thread.join(AT_EXIT_THREAD_JOIN_TIMEOUT_SECONDS)
-        end
-        sync
-      rescue StandardError => e
-        LOG.debug "[quonfig] at_exit telemetry drain failed: #{e.class}: #{e.message}"
-      end
-
-      def post(payload)
-        conn = http_connection
-        return if conn.nil?
-
-        response = conn.post('/api/v1/telemetry/', payload)
-        status = response.respond_to?(:status) ? response.status : nil
-        if status && status >= 400
-          LOG.warn "[quonfig] Telemetry POST failed: #{status}"
-        else
-          LOG.debug "[quonfig] Telemetry POST ok: events=#{payload['events'].size}"
-        end
-        response
-      end
-
-      def http_connection
-        @http_connection ||= begin
-          return nil if @sdk_key.nil? || @telemetry_destination.nil?
-
-          Quonfig::HttpConnection.new(@telemetry_destination, @sdk_key)
-        end
-      end
-
-      def calculate_sync_interval(sync_interval)
-        return proc { sync_interval } if sync_interval.is_a?(Numeric)
-        return sync_interval if sync_interval.respond_to?(:call)
-
-        Quonfig::ExponentialBackoff.new(
-          initial_delay: DEFAULT_INITIAL_DELAY_SECONDS,
-          max_delay: DEFAULT_MAX_DELAY_SECONDS,
-          multiplier: 1.5
-        )
+        close
       end
     end
   end