Playing with transfer_encoding: chunked

config.ru

require './data_source'
require './stream_observer'
require './streaming_app'

source = DataSource.new

app = StreamingApp.new

app.settings.set :stream_observer_factory,
  -> type { StreamObserver.new(source, type) }

run app

data_source.rb

require 'observer'

StreamItem = Struct.new(:type, :message)

class DataSource
  include Observable

  def initialize
    @counter = 0
    Thread.new do
      loop do
        increment_counter
        sleep 1
      end
    end
  end

  private

  def increment_counter
    @counter += 1
    changed
    notify_observers(StreamItem.new(:counter, @counter))
  end
end

stream_observer.rb

require 'json'

class StreamObserver
  include Enumerable

  def initialize(source, *types_filter)
    @source = source
    @message_queue = Queue.new
    @types_filter = types_filter
    @source.add_observer(self, :receive_stream_item)
  end

  def receive_stream_item(item)
    @message_queue.push item.to_h.to_json if @types_filter.include? item.type
  end

  def each
    begin
      loop { yield @message_queue.pop }
    ensure
      @source.delete_observer self
    end
  end
e

streaming_app.rb

require 'sinatra/base'

class StreamingApp < Sinatra::Base
  get '/counter' do
    settings.stream_observer_factory(:counter).lazy.map { |count| "#{count} <br/>" }
  end
end