feat-sdk 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f64fac3df2e3ba9d2dc9db569472dd8329bea2d4fb4f2117d44e65a45d9e652
-  data.tar.gz: 4d60e7877bc7df301aa90a96bd19b11c211d6941387ffe834793c84db04ad353
+  metadata.gz: 96fb093819af9d5ad6b3caf1e2d7dbe8bb54615c72c96d44c54a50e90a5b2ec4
+  data.tar.gz: 62b5a48dfc8bd4917567aff1c43ca75907b9f474f3ae60500b73d53b58dd57c2
 SHA512:
-  metadata.gz: 2a990fc8a48b6176329fc664001c314b37fd5523122d91481700f804df7ec0d75f9705167eced27696627de0bfa25b895e0950b7aa69dd2d73785d917b7175b3
-  data.tar.gz: 8bbbed51ad214a26652743a15f036ea1936f431d74606c634f63282bfaaaee67310606e9110748a46385b9fa5786e441a6cd3690666a146c924ba4324420a1f2
+  metadata.gz: 8cc1f3d77862b0fa9adde4d8c5a766bc2ab17e040cd791054c8fbde8199e9764067412e48d451283c8a3d47c6484cb317b83aefb63efda48a1249e65eca2859a
+  data.tar.gz: c6f7fac4513cbcdcdcd605d8a326ce858638a2a8da6f9bed01f834f696c5d792323471fe6d77ec631ec671307da82bd54b6fa3587374f66cded36c75919d794f

data/README.md

@@ -1,6 +1,14 @@
-# feat-sdk
+<p align="center">
+  <a href="https://feat.so">
+    <img src="https://feat.so/logo/wordmark.png" alt="feat.so" width="320" />
+  </a>
+</p>
 
-Server-side Ruby SDK for [feat](https://feat.so) feature flags. Local flag evaluation against a polled datafile. Standard library only - no gem dependencies.
+---
+
+# feat Ruby SDK
+
+Server-side Ruby SDK for [feat](https://feat.so) feature flags. Local flag evaluation against a live-streamed datafile. Standard library only - no gem dependencies.
 
 ## Install
 
@@ -22,7 +30,7 @@ require "feat"
 
 client = Feat::Client.new(
   api_key: ENV.fetch("FEAT_SERVER_KEY"),
-  data_plane_url: "https://data.feat.so",
+  url: "https://data-01.feat.so", # optional; this is the default
 )
 client.start
 
@@ -43,9 +51,30 @@ Use a **server** API key (`feat_sdk_...`).
 ## How it works
 
 - Fetches a per-environment datafile and keeps it in memory.
-- Polls every 30 seconds by default. ETag-aware via `If-None-Match`.
+- Streams updates over Server-Sent Events: a background thread holds an open
+  connection and applies each new datafile the instant it changes. Updates are
+  version-ordered (an older or equal datafile is never adopted) and guarded by a
+  mutex shared with the evaluator.
+- Keeps a slow background poll (every 5 minutes by default) as a safety net.
+  ETag-aware via `If-None-Match`. If the stream drops, it reconnects with
+  exponential backoff while the poll keeps the datafile fresh.
 - Evaluation runs in-process: no per-flag network call.
-- A background thread handles polling; `close` stops it cleanly.
+- `close` stops the stream and poll threads cleanly.
+
+### Streaming options
+
+Streaming is on by default. To disable it and rely on polling alone:
+
+```ruby
+client = Feat::Client.new(
+  api_key: ENV.fetch("FEAT_SERVER_KEY"),
+  streaming: false,        # poll-only mode
+  poll_interval: 30,       # seconds (used when streaming is off)
+)
+```
+
+When streaming is on, `safety_poll_interval:` (default 300 seconds) controls the
+backstop poll cadence.
 
 ## License
 

data/lib/feat/client.rb

@@ -1,39 +1,80 @@
 require "json"
 require "net/http"
+require "socket"
 require "uri"
+require_relative "version"
+require_relative "sse"
+require_relative "streaming"
 
 module Feat
-  # Polling HTTP client. Uses stdlib only - zero gem dependencies.
+  # HTTP client. Uses stdlib only - zero gem dependencies.
+  #
+  # By default the client streams datafile updates over Server-Sent Events
+  # and keeps a slow background poll as a safety net. Disable streaming with
+  # `streaming: false` to fall back to polling alone.
   class Client
+    include InterruptibleSleep
+
+    DEFAULT_URL = "https://data-01.feat.so"
     DEFAULT_POLL_INTERVAL = 30.0
+    # When streaming carries updates, the poll is a backstop only and runs
+    # far less often.
+    DEFAULT_SAFETY_POLL_INTERVAL = 300.0
     MIN_POLL_INTERVAL = 5.0
     MAX_DATAFILE_BYTES = 10 * 1024 * 1024
-
-    def initialize(api_key:, data_plane_url:, poll_interval: DEFAULT_POLL_INTERVAL, http_client: nil)
+    OPEN_TIMEOUT_SECONDS = 3
+    READ_TIMEOUT_SECONDS = 10
+    # Long-lived stream read: heartbeat comments keep it well under this.
+    STREAM_READ_TIMEOUT_SECONDS = 90
+    # Bound on how long #close waits for the poll thread to unwind, so a
+    # blocked fetch cannot make shutdown hang indefinitely.
+    POLL_JOIN_TIMEOUT_SECONDS = 5
+    RETRYABLE_CONNECT_ERRORS = [
+      Net::OpenTimeout,
+      Errno::ETIMEDOUT,
+      Errno::ECONNREFUSED,
+      Errno::EHOSTUNREACH,
+      Errno::ENETUNREACH,
+    ].freeze
+
+    def initialize(api_key:, url: DEFAULT_URL, poll_interval: DEFAULT_POLL_INTERVAL,
+                   streaming: true, safety_poll_interval: DEFAULT_SAFETY_POLL_INTERVAL,
+                   http_client: nil, stream_transport: nil)
       raise ArgumentError, "api_key is required" if api_key.nil? || api_key.empty?
-      raise ArgumentError, "data_plane_url is required" if data_plane_url.nil? || data_plane_url.empty?
 
-      assert_https_url!(data_plane_url)
-
-      @api_key       = api_key
-      @data_plane_url = data_plane_url.chomp("/")
-      @poll_interval = [poll_interval.to_f, MIN_POLL_INTERVAL].max
-      @http_client   = http_client
-      @datafile      = nil
-      @etag          = nil
-      @mutex         = Mutex.new
-      @stop          = false
-      @thread        = nil
+      assert_https_url!(url)
+
+      @api_key           = api_key
+      @url               = url.chomp("/")
+      @streaming_enabled = streaming
+      base_interval      = streaming ? safety_poll_interval : poll_interval
+      @poll_interval     = [base_interval.to_f, MIN_POLL_INTERVAL].max
+      @http_client       = http_client
+      @datafile          = nil
+      @etag              = nil
+      @mutex             = Mutex.new
+      @stop              = false
+      @thread            = nil
+      @sticky_ip         = nil
+      @streaming         = build_streaming_client(stream_transport) if @streaming_enabled
     end
 
-    # Blocking initial fetch; spawns a background poller thread.
+    # Blocking initial fetch; spawns the background poller (and stream).
     def start
       refresh
+      @streaming&.start
       @thread ||= Thread.new { poll_loop }
+      self
     end
 
     def close
       @stop = true
+      @streaming&.stop
+      # Join the poll thread (bounded) so a fetch in flight is waited out and
+      # @thread is cleared, leaving the client cleanly restartable.
+      @thread&.join(POLL_JOIN_TIMEOUT_SECONDS)
+      @thread = nil
+      self
     end
 
     def refresh
@@ -77,14 +118,29 @@ module Feat
       uri = URI.parse(url)
       return if uri.scheme == "https"
       return if uri.scheme == "http" && %w[localhost 127.0.0.1].include?(uri.host)
-      raise ArgumentError, "data_plane_url must use https:// (http://localhost allowed for tests)"
+      raise ArgumentError, "url must use https:// (http://localhost allowed for tests)"
     rescue URI::InvalidURIError
-      raise ArgumentError, "data_plane_url is not a valid URL"
+      raise ArgumentError, "url is not a valid URL"
+    end
+
+    # Builds the streaming client; its `put` handler runs through the same
+    # version-guarded store as polling, so an older frame never wins.
+    def build_streaming_client(transport)
+      transport ||= NetHTTPStreamTransport.new(
+        open_timeout: OPEN_TIMEOUT_SECONDS,
+        read_timeout: STREAM_READ_TIMEOUT_SECONDS,
+      )
+      StreamingClient.new(
+        url: @url,
+        api_key: @api_key,
+        transport: transport,
+        on_put: ->(parsed) { store_datafile(parsed, parsed["etag"]) },
+      )
     end
 
     def poll_loop
       until @stop
-        sleep @poll_interval
+        interruptible_sleep(@poll_interval) { @stop }
         break if @stop
 
         begin
@@ -96,14 +152,13 @@ module Feat
     end
 
     def fetch_once
-      uri = URI.parse("#{@data_plane_url}/sdk/v1/datafile")
+      uri = URI.parse("#{@url}/sdk/v1/datafile")
       req = Net::HTTP::Get.new(uri)
       req["Authorization"] = "Bearer #{@api_key}"
+      req["User-Agent"] = "feat-sdk-ruby/#{Feat::VERSION}"
       @mutex.synchronize { req["If-None-Match"] = @etag if @etag }
 
-      res = (@http_client || Net::HTTP).start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
-        http.request(req)
-      end
+      res = with_http_connection(uri) { |http| http.request(req) }
 
       case res.code.to_i
       when 304, 404
@@ -113,16 +168,87 @@ module Feat
         raise "datafile exceeds maximum allowed size" if length && length > MAX_DATAFILE_BYTES
         body = res.body
         raise "datafile exceeds maximum allowed size" if body.bytesize > MAX_DATAFILE_BYTES
-        data = JSON.parse(body)
-        new_etag = res["ETag"]
-        @mutex.synchronize do
-          @datafile = Datafile.from_json(data)
-          @etag = new_etag if new_etag
-        end
-        true
+        store_datafile(JSON.parse(body), res["ETag"])
       else
         raise "feat: fetch datafile failed: #{res.code}"
       end
     end
+
+    # Adopt a parsed datafile only if its version is strictly newer than the
+    # one in memory. Shared by the poll and stream paths and guarded by the
+    # same mutex the evaluator reads through. Returns true when adopted.
+    def store_datafile(parsed, etag)
+      candidate = Datafile.from_json(parsed)
+      @mutex.synchronize do
+        current_version = @datafile&.version
+        new_version = candidate.version
+        return false if new_version && current_version && new_version <= current_version
+
+        @datafile = candidate
+        @etag = etag if etag
+      end
+      true
+    end
+
+    # Net::HTTP doesn't iterate getaddrinfo results on connect failure
+    # (Ruby 3.3 has no Happy Eyeballs); ipaddr= lets us pin each attempt
+    # to a specific IP while keeping the hostname for SNI.
+    def with_http_connection(uri, &block)
+      if @http_client
+        return @http_client.start(
+          uri.host, uri.port,
+          use_ssl: uri.scheme == "https",
+          open_timeout: OPEN_TIMEOUT_SECONDS,
+          read_timeout: READ_TIMEOUT_SECONDS,
+        ) { |h| block.call(h) }
+      end
+
+      sticky = @mutex.synchronize { @sticky_ip }
+      if sticky
+        begin
+          return attempt_request(uri, sticky, &block)
+        rescue *RETRYABLE_CONNECT_ERRORS
+          @mutex.synchronize { @sticky_ip = nil if @sticky_ip == sticky }
+        end
+      end
+
+      addresses = resolve_addresses(uri.host)
+      if addresses.empty?
+        return Net::HTTP.start(
+          uri.host, uri.port,
+          use_ssl: uri.scheme == "https",
+          open_timeout: OPEN_TIMEOUT_SECONDS,
+          read_timeout: READ_TIMEOUT_SECONDS,
+        ) { |h| block.call(h) }
+      end
+
+      last_error = nil
+      addresses.each do |ip|
+        next if ip == sticky
+        begin
+          result = attempt_request(uri, ip, &block)
+          @mutex.synchronize { @sticky_ip = ip }
+          return result
+        rescue *RETRYABLE_CONNECT_ERRORS => e
+          last_error = e
+        end
+      end
+      raise last_error
+    end
+
+    def attempt_request(uri, ip, &block)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.ipaddr = ip
+      http.use_ssl = (uri.scheme == "https")
+      http.open_timeout = OPEN_TIMEOUT_SECONDS
+      http.read_timeout = READ_TIMEOUT_SECONDS
+      http.start { |h| block.call(h) }
+    end
+
+    def resolve_addresses(host)
+      Addrinfo.getaddrinfo(host, nil, nil, :STREAM).map(&:ip_address).uniq
+    rescue StandardError
+      []
+    end
   end
 end

data/lib/feat/sse.rb

@@ -0,0 +1,88 @@
+module Feat
+  # Raised when a single SSE event (its in-flight buffer plus accumulated
+  # data) grows past the configured byte cap. Aborts the connection rather
+  # than letting a missing newline or a giant data field exhaust memory.
+  class SSEOverflowError < StandardError; end
+
+  # Incremental Server-Sent Events parser. Pure: it does no IO.
+  #
+  # Feed raw response bytes with #feed; the parser buffers, splits on
+  # newline boundaries, and yields one Hash per dispatched event:
+  #
+  #   { event: "put", data: "<json>", id: "42" }
+  #
+  # Per the SSE wire format:
+  #   - "field: value" lines set the event/data/id of the pending event;
+  #     a single leading space after the colon is stripped from the value.
+  #   - "data:" lines accumulate and are joined with "\n".
+  #   - A blank line dispatches the pending event.
+  #   - Lines starting with ":" are comments (heartbeats) and are ignored.
+  class SSEParser
+    # Upper bound on the bytes held for one in-progress event. Mirrors
+    # Client::MAX_DATAFILE_BYTES so the stream path is bounded the same way
+    # the poll path is.
+    MAX_EVENT_BYTES = 10 * 1024 * 1024
+
+    def initialize(max_event_bytes: MAX_EVENT_BYTES)
+      @max_event_bytes = max_event_bytes
+      @buffer = +""
+      reset_event
+    end
+
+    # Append a chunk of bytes and yield each fully-formed event.
+    def feed(chunk)
+      @buffer << chunk
+      while (idx = @buffer.index("\n"))
+        line = @buffer.slice!(0, idx + 1)
+        # String#chomp strips a trailing "\r\n", "\n", or "\r".
+        process_line(line.chomp) { |event| yield event }
+      end
+      # A line that never terminates, or a single oversized data field, must
+      # not grow the buffers without bound. Abort once past the cap.
+      guard_size!
+    end
+
+    private
+
+    def guard_size!
+      buffered = @buffer.bytesize
+      @data.each { |segment| buffered += segment.bytesize }
+      return if buffered <= @max_event_bytes
+
+      raise SSEOverflowError, "SSE event exceeds #{@max_event_bytes} bytes"
+    end
+
+    def process_line(line)
+      if line.empty?
+        dispatch { |event| yield event }
+        return
+      end
+      return if line.start_with?(":") # heartbeat / comment
+
+      field, sep, value = line.partition(":")
+      # A bare "field" with no colon is ignored (no value to set).
+      return if sep.empty?
+
+      value = value[1..] if value.start_with?(" ")
+      case field
+      when "event" then @event = value
+      when "data"  then @data << value
+      when "id"    then @id = value
+      end
+    end
+
+    def dispatch
+      # Nothing buffered between two blank lines -> nothing to emit.
+      return if @event.nil? && @data.empty? && @id.nil?
+
+      yield({ event: @event || "message", data: @data.join("\n"), id: @id })
+      reset_event
+    end
+
+    def reset_event
+      @event = nil
+      @data = []
+      @id = nil
+    end
+  end
+end

data/lib/feat/streaming.rb

@@ -0,0 +1,253 @@
+require "json"
+require "net/http"
+require "uri"
+require_relative "version"
+require_relative "sse"
+
+module Feat
+  # Raised when the stream endpoint answers with a non-200 status. +code+
+  # carries the HTTP status so the run loop can tell terminal auth failures
+  # (401 invalid/revoked/expired key, 403 origin not allowed) apart from
+  # retryable ones (429 rate limit, 5xx).
+  class StreamError < StandardError
+    attr_reader :code
+
+    def initialize(message, code: nil)
+      super(message)
+      @code = code
+    end
+  end
+
+  # Sleeps that wake promptly when a stop flag flips, so background threads
+  # shut down without waiting out a full interval.
+  module InterruptibleSleep
+    SLEEP_GRANULARITY = 0.1
+
+    private
+
+    def interruptible_sleep(seconds, &stop)
+      deadline = monotonic + seconds
+      loop do
+        return if stop.call
+
+        remaining = deadline - monotonic
+        return if remaining <= 0
+
+        sleep([SLEEP_GRANULARITY, remaining].min)
+      end
+    end
+
+    def monotonic
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+
+  # Default SSE transport built on Net::HTTP streaming reads. Injectable so
+  # tests can supply a fake that yields canned chunks.
+  class NetHTTPStreamTransport
+    def initialize(open_timeout:, read_timeout:)
+      @open_timeout = open_timeout
+      @read_timeout = read_timeout
+    end
+
+    # Open a streaming GET and return a connection handle.
+    def connect(uri:, headers:)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.open_timeout = @open_timeout
+      http.read_timeout = @read_timeout
+      http.start
+      Connection.new(http, uri, headers)
+    end
+
+    # Wraps a started Net::HTTP connection. #each_chunk blocks while the
+    # server holds the stream open; #close aborts it from another thread.
+    class Connection
+      def initialize(http, uri, headers)
+        @http = http
+        @request = Net::HTTP::Get.new(uri)
+        headers.each { |name, value| @request[name] = value }
+      end
+
+      def each_chunk
+        @http.request(@request) do |response|
+          code = response.code.to_i
+          raise StreamError.new("datafile stream failed: HTTP #{code}", code: code) unless code == 200
+
+          response.read_body { |chunk| yield chunk }
+        end
+      end
+
+      def close
+        @http.finish if @http.started?
+      rescue StandardError
+        nil
+      end
+    end
+  end
+
+  # Holds a long-lived SSE connection to the datafile stream endpoint and
+  # invokes +on_put+ with the parsed datafile for every `put` frame. Runs on
+  # its own thread, reconnects with exponential backoff, and stops cleanly.
+  class StreamingClient
+    include InterruptibleSleep
+
+    PATH = "/sdk/v1/datafile/stream".freeze
+    DEFAULT_INITIAL_BACKOFF = 1.0
+    DEFAULT_MAX_BACKOFF = 60.0
+    # A connection must stay open at least this long before we treat it as
+    # healthy and reset backoff. The server seeds a `put` on every
+    # (re)connect, so "an event arrived" alone does not prove the connection
+    # is stable: a server that seeds then immediately drops would otherwise
+    # pin us to a fixed ~1s reconnect cadence forever.
+    DEFAULT_MIN_UPTIME = 5.0
+    # HTTP statuses that will never succeed with this key/origin, so we stop
+    # retrying: 401 (invalid/revoked/expired key), 403 (origin not allowed).
+    TERMINAL_STREAM_CODES = [401, 403].freeze
+    JOIN_TIMEOUT_SECONDS = 5
+
+    def initialize(url:, api_key:, transport:, on_put:, on_error: nil,
+                   initial_backoff: DEFAULT_INITIAL_BACKOFF,
+                   max_backoff: DEFAULT_MAX_BACKOFF,
+                   min_uptime: DEFAULT_MIN_UPTIME,
+                   max_event_bytes: SSEParser::MAX_EVENT_BYTES)
+      @url             = url.chomp("/")
+      @api_key         = api_key
+      @transport       = transport
+      @on_put          = on_put
+      @on_error        = on_error
+      @initial_backoff = initial_backoff
+      @max_backoff     = max_backoff
+      @min_uptime      = min_uptime
+      @max_event_bytes = max_event_bytes
+      @mutex           = Mutex.new
+      @conn            = nil
+      @thread          = nil
+      @stop            = false
+    end
+
+    def start
+      @thread ||= Thread.new { run_loop }
+      self
+    end
+
+    # Signal shutdown, abort any in-flight read, and join the thread.
+    def stop
+      @stop = true
+      current = @mutex.synchronize { @conn }
+      begin
+        current&.close
+      rescue StandardError
+        nil
+      end
+      @thread&.join(JOIN_TIMEOUT_SECONDS)
+      @thread = nil
+      self
+    end
+
+    private
+
+    def run_loop
+      backoff = @initial_backoff
+      until @stop
+        started_at = monotonic
+        terminal = false
+        begin
+          stream_once
+        rescue StreamError => e
+          notify_error(e)
+          terminal = terminal_stream_error?(e)
+        rescue StandardError => e
+          notify_error(e)
+        end
+        break if @stop || terminal
+
+        # Only reset backoff for a connection that proved itself by staying
+        # open past the minimum uptime, not merely because the seeded `put`
+        # was received.
+        backoff = @initial_backoff if (monotonic - started_at) >= @min_uptime
+        # Equal jitter spreads reconnects so a fleet does not stampede a
+        # restarting relay. The un-jittered backoff feeds the next doubling.
+        interruptible_sleep(apply_jitter(backoff)) { @stop }
+        backoff = next_backoff(backoff)
+      end
+    end
+
+    def terminal_stream_error?(error)
+      error.is_a?(StreamError) && TERMINAL_STREAM_CODES.include?(error.code)
+    end
+
+    # Equal jitter: sleep half the window plus a random slice of the other
+    # half, keeping the delay within [backoff/2, backoff].
+    def apply_jitter(backoff)
+      half = backoff / 2.0
+      half + (rand * half)
+    end
+
+    def next_backoff(backoff)
+      [backoff * 2, @max_backoff].min
+    end
+
+    def stream_once
+      uri = URI.parse("#{@url}#{PATH}")
+      conn = @transport.connect(uri: uri, headers: stream_headers)
+      @mutex.synchronize { @conn = conn }
+
+      parser = SSEParser.new(max_event_bytes: @max_event_bytes)
+      conn.each_chunk do |chunk|
+        break if @stop
+
+        parser.feed(chunk) { |event| handle_event(event) }
+      end
+    ensure
+      closing = @mutex.synchronize do
+        held = @conn
+        @conn = nil
+        held
+      end
+      begin
+        closing&.close
+      rescue StandardError
+        nil
+      end
+    end
+
+    def handle_event(event)
+      return unless event[:event] == "put"
+
+      raw = event[:data]
+      return if raw.nil? || raw.empty?
+
+      parsed =
+        begin
+          JSON.parse(raw)
+        rescue JSON::ParserError
+          return
+        end
+
+      @on_put.call(parsed)
+    rescue StandardError => e
+      notify_error(e)
+    end
+
+    # We deliberately do not send a Last-Event-ID header to resume. The
+    # server reseeds the full datafile on every (re)connect and ignores any
+    # resume cursor, and store_datafile is version-guarded so a re-pushed
+    # snapshot is a no-op. The parsed event id is therefore left unused:
+    # tracking it for resume would be dead code.
+    def stream_headers
+      {
+        "Authorization" => "Bearer #{@api_key}",
+        "User-Agent"    => "feat-sdk-ruby/#{Feat::VERSION}",
+        "Accept"        => "text/event-stream",
+        "Cache-Control" => "no-cache",
+      }
+    end
+
+    def notify_error(error)
+      @on_error&.call(error)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/feat/version.rb

@@ -1,3 +1,3 @@
 module Feat
-  VERSION = "0.1.0".freeze
+  VERSION = "0.2.0".freeze
 end

data/lib/feat.rb

@@ -5,6 +5,8 @@ require "feat/bucketing"
 require "feat/operators"
 require "feat/segments"
 require "feat/eval"
+require "feat/sse"
+require "feat/streaming"
 require "feat/client"
 
 # Feat - feature-flag SDK for Ruby.

metadata

@@ -1,18 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: feat-sdk
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - feat HQ
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-06-27 00:00:00.000000000 Z
 dependencies: []
 description: Server-side Ruby SDK for feat. Polls a per-environment datafile and evaluates
   flags locally with no per-flag network call. Stdlib only.
 email:
-- engineering@feat.so
+- support@feat.so
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -27,6 +28,8 @@ files:
 - lib/feat/eval.rb
 - lib/feat/operators.rb
 - lib/feat/segments.rb
+- lib/feat/sse.rb
+- lib/feat/streaming.rb
 - lib/feat/version.rb
 homepage: https://feat.so
 licenses:
@@ -36,6 +39,7 @@ metadata:
   source_code_uri: https://github.com/feathq/ruby-sdk
   bug_tracker_uri: https://github.com/feathq/ruby-sdk/issues
   changelog_uri: https://github.com/feathq/ruby-sdk/releases
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -50,7 +54,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: feat feature-flag SDK for Ruby (server-side, local evaluation)
 test_files: []