feat-sdk 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50c482a000c1e2ef525db051f580656d302cfbc0cb983c0241507615cd3d6b87
-  data.tar.gz: 1e52811533d9ba5d42805e2a9b665b626b984a1d30df61dfaa97fdacc90fe2f1
+  metadata.gz: 4dfb1cd9905d46890db88dea9411a6dc3755208286fbbec6565d8742459d5008
+  data.tar.gz: 63c030396f376ff362b3d0d5b7c07a7cc926b4dd5141c9516988dbcb87a3419f
 SHA512:
-  metadata.gz: 40b5b6c2ab9fa985ac32c17bf39b4606c8e38a271e0e526383d2c7e1824348107f526d67350cc06dd60e5c4fd186a5df0ff41bad20f12353d1ddbf5cb3de583b
-  data.tar.gz: c41a41b359e9cd68664189fa9271b99346f67fbd4fa6286d56ec116d9cfeabf3788b16d68ad9c20bb5eb4e65f14a0760c05bacb06fc2fcd607435bb751fae213
+  metadata.gz: 347f444e5f8354f9b4b4d8957c812bde443a502b7c6cc54623df05983abe332cafd77f37ffebbb01d8cd8e8940d280a8004068e16403398721b2bb6bcc2ec4c6
+  data.tar.gz: e192084e64f93ff51ab4e14aa4384ec0954be13f6e4996c00371185deee30a9fe67b718d3065a07b64d2bd15dd98a4bfcf0677bb54e67a0959015ad542504fee

data/README.md

@@ -8,7 +8,7 @@
 
 # feat Ruby SDK
 
-Server-side Ruby SDK for [feat](https://feat.so) feature flags. Local flag evaluation against a polled datafile. Standard library only - no gem dependencies.
+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
 
@@ -30,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
 
@@ -51,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

@@ -3,15 +3,32 @@ 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
     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,
@@ -20,32 +37,44 @@ module Feat
       Errno::ENETUNREACH,
     ].freeze
 
-    def initialize(api_key:, data_plane_url:, poll_interval: DEFAULT_POLL_INTERVAL, http_client: nil)
+    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)
+      assert_https_url!(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
-      @sticky_ip     = nil
+      @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
@@ -89,14 +118,56 @@ 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"]) },
+        on_patch: ->(parsed) { apply_patch(parsed) },
+      )
+    end
+
+    # Apply a streamed `patch` delta. Version-gated: the delta is merged only
+    # when the in-memory datafile's version equals the patch's +from+, so the
+    # result is exactly the +to+ snapshot. On any gap or mismatch the patch is
+    # ignored - a reconnect reseeds a full `put` and the safety poll backstops.
+    # Runs under the same mutex as store_datafile, so a subsequent evaluation
+    # sees the merged delta atomically. Returns true when applied.
+    def apply_patch(patch)
+      from = patch["from"]
+      to   = patch["to"]
+      # Reject malformed or out-of-order deltas before touching the datafile:
+      # both bounds must be integers and the patch must move strictly forward.
+      # Without the `to > from` guard a backward `to` would roll the in-memory
+      # version backward and break version ordering.
+      return false unless from.is_a?(Integer) && to.is_a?(Integer) && to > from
+
+      @mutex.synchronize do
+        current = @datafile
+        return false if current.nil?
+        return false unless current.version == from
+
+        @datafile = Datafile.merge_patch(current, patch)
+        @etag = patch["etag"] if patch["etag"]
+      end
+      true
     end
 
     def poll_loop
       until @stop
-        sleep @poll_interval
+        interruptible_sleep(@poll_interval) { @stop }
         break if @stop
 
         begin
@@ -108,7 +179,7 @@ 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}"
@@ -124,18 +195,28 @@ 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.

data/lib/feat/datafile.rb

@@ -49,6 +49,36 @@ module Feat
       )
     end
 
+    # Merge a patch delta onto an existing File and return a new File. Pure:
+    # +current+ is not mutated. Added or changed flags/segments are built
+    # from their wire objects and override by key; removed keys are dropped.
+    # version, etag, and generatedAt advance to the patch's values (etag and
+    # generatedAt fall back to the current ones when the patch omits them).
+    # Raises if a flag or segment object is malformed; the caller treats that
+    # as a no-op and ignores the patch.
+    def self.merge_patch(current, patch)
+      flags = current.flags.dup
+      (patch["flags"] || {}).each { |k, v| flags[k] = build_flag(v) }
+      (patch["removedFlags"] || []).each { |k| flags.delete(k) }
+
+      segments = current.segments.dup
+      (patch["segments"] || {}).each { |k, v| segments[k] = build_segment(v) }
+      (patch["removedSegments"] || []).each { |k| segments.delete(k) }
+
+      File.new(
+        schemaVersion: current.schemaVersion,
+        envId:         current.envId,
+        envKey:        current.envKey,
+        projectId:     current.projectId,
+        version:       patch["to"],
+        etag:          patch["etag"] || current.etag,
+        generatedAt:   patch["generatedAt"] || current.generatedAt,
+        flags:         flags,
+        segments:      segments,
+        contextKinds:  current.contextKinds
+      )
+    end
+
     def self.build_flag(d)
       FlagSpec.new(
         id:                             d["id"],

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,264 @@
+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 and
+  # +on_patch+ with the parsed delta for every `patch` 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_patch: nil, 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_patch        = on_patch
+      @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)
+      case event[:event]
+      when "put"   then with_parsed_payload(event) { |parsed| @on_put.call(parsed) }
+      when "patch" then with_parsed_payload(event) { |parsed| @on_patch&.call(parsed) }
+      end
+    rescue StandardError => e
+      notify_error(e)
+    end
+
+    # Decode the event's JSON data field and hand it to the block. A missing,
+    # empty, or unparseable payload is dropped silently (the next frame or a
+    # reconnect recovers); any error the block raises bubbles to the caller's
+    # rescue and is surfaced via on_error.
+    def with_parsed_payload(event)
+      raw = event[:data]
+      return if raw.nil? || raw.empty?
+
+      parsed =
+        begin
+          JSON.parse(raw)
+        rescue JSON::ParserError
+          return
+        end
+
+      yield parsed
+    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.1".freeze
+  VERSION = "0.3.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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: feat-sdk
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - feat HQ
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-04 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.
@@ -28,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: