module ActionController::Live

def log_error(exception) 

def log_error(exception)
  logger = ActionController::Base.logger
  return unless logger
  logger.fatal do
    message = +"\n#{exception.class} (#{exception.message}):\n"
    message << exception.annotated_source_code.to_s if exception.respond_to?(:annotated_source_code)
    message << "  " << exception.backtrace.join("\n  ")
    "#{message}\n\n"
  end
end

def new_controller_thread # :nodoc:

:nodoc:
this method except in Rails internals. Seriously!
a thread to stream data from the response bodies. Nobody should call
around the fact that Rack isn't based around IOs and we need to use
Spawn a new thread to serve up the controller in. This is to get 
def new_controller_thread # :nodoc:
  Thread.new {
    t2 = Thread.current
    t2.abort_on_exception = true
    yield
  }
end

def new_controller_thread # :nodoc:

:nodoc: 
def new_controller_thread # :nodoc:
  yield
end

def process(name) 

def process(name)
  t1 = Thread.current
  locals = t1.keys.map { |key| [key, t1[key]] }
  error = nil
  # This processes the action in a child thread. It lets us return the
  # response code and headers back up the Rack stack, and still process
  # the body in parallel with sending data to the client.
  new_controller_thread {
    ActiveSupport::Dependencies.interlock.running do
      t2 = Thread.current
      # Since we're processing the view in a different thread, copy the
      # thread locals from the main thread to the child thread. :'(
      locals.each { |k, v| t2[k] = v }
      ActiveSupport::IsolatedExecutionState.share_with(t1)
      begin
        super(name)
      rescue => e
        if @_response.committed?
          begin
            @_response.stream.write(ActionView::Base.streaming_completion_on_exception) if request.format == :html
            @_response.stream.call_on_error
          rescue => exception
            log_error(exception)
          ensure
            log_error(e)
            @_response.stream.close
          end
        else
          error = e
        end
      ensure
        @_response.commit!
      end
    end
  }
  ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
    @_response.await_commit
  end
  raise error if error
end

def response_body=(body) 

def response_body=(body)
  super
  response.close if response
end

def send_stream(filename:, disposition: "attachment", type: nil)

end
end
stream.write "#{subscriber.email_address},#{subscriber.updated_at}\n"
@subscribers.find_each do |subscriber|

stream.write "email_address,updated_at\n"
send_stream(filename: "subscribers.csv") do |stream|

Example of generating a csv export:

Valid values are 'inline' and 'attachment' (default).
* :disposition - specifies whether the file will be shown inline or downloaded.
If no content type is registered for the extension, the default type 'application/octet-stream' will be used.
If omitted, type will be inferred from the file extension specified in :filename.
You can specify either a string or a symbol for a registered type with Mime::Type.register, for example :json.
* :type - specifies an HTTP content type.
* :filename - suggests a filename for the browser to use.
Options:

don't want the entire file buffered in memory first. Similar to send_data, but where the data is generated live.
Sends a stream to the browser, which is helpful when you're generating exports or other running data where you 
def send_stream(filename:, disposition: "attachment", type: nil)
  response.headers["Content-Type"] =
    (type.is_a?(Symbol) ? Mime[type].to_s : type) ||
    Mime::Type.lookup_by_extension(File.extname(filename).downcase.delete("."))&.to_s ||
    "application/octet-stream"
  response.headers["Content-Disposition"] =
    ActionDispatch::Http::ContentDisposition.format(disposition: disposition, filename: filename)
  yield response.stream
ensure
  response.stream.close
end