falcon 0.52.0 → 0.52.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcc66fb374ec0ceeca20dcae8772a96d406437cf338ac4239eaa30513790fc88
-  data.tar.gz: f29e1b1d98923d791d05ed6e192995fa37d2cf562c18c848ff5b1c4491bc7eb0
+  metadata.gz: 95ff41d54e933c37257afda238572f60d9d73cbc7a8d4e9455b114fcee69a35d
+  data.tar.gz: 0db20e527e3dbe621863bcb222082a1a6798357e7a5b667a7e333cfc4f10b35f
 SHA512:
-  metadata.gz: 1d8d9189a0c0283a91229d6f05e7bf03dc29a0735d38edd7911f7475d23849b276d0b1355bb01e7b1d87c139c29ea641c9fd556111e5f45159cf270c29ad3992
-  data.tar.gz: 7c6f1a409420925dd0d5780370706a54f080e8aede006349421342e92ea59d2b54586470e650415dcfdc68650e1c6d80a3c6d8711dc494326acb2e68ca4d46df
+  metadata.gz: 26ca76ce7cf101b8ec3f0767b7c4fafa8edd6aa826622b22b861ebfc57c64baa7dec02693188ed57ef6756fd9f3919d274908ba5c975f79801197c7f9f26652c
+  data.tar.gz: 9ab2fa4115477cfb45359c8765ae3ee9540372fe4198f2534792bec94784b3471e28a9047767b2f4ec6e8848606675779147acfe7360d6cf89997a3cd5eb6842

data/context/deployment.md

@@ -0,0 +1,166 @@
+# Deployment
+
+This guide explains how to use Falcon in production environments.
+
+Falcon can be deployed into production either as a standalone application server, or as a virtual host routing to multiple applications. Both configurations can run behind a load balancer, but `falcon virtual` is designed to be zero-configuration deployment option.
+
+## Falcon Serve
+
+`falcon serve` is not designed for deployment because the command line interface is not guaranteed to be stable nor does it expose every possible configuration option.
+
+## Falcon Hosts
+
+`falcon host` is designed for deployment, and is the recommended way to deploy Falcon in production. It exposes a well defined interface for configuring services (web applications, job servers, etc).
+
+### Configuration
+
+`falcon host` loads configuration from the `falcon.rb` file in your application directory. This file contains configuration blocks which define how to host the application and any related services. This file should be executable and it invokes `falcon-host` which starts all defined services.
+
+Here is a basic example which hosts a rack application:
+
+~~~ ruby
+#!/usr/bin/env falcon-host
+# frozen_string_literal: true
+
+require "falcon/environment/rack"
+require "falcon/environment/lets_encrypt_tls"
+require "falcon/environment/supervisor"
+
+hostname = File.basename(__dir__)
+service hostname do
+	include Falcon::Environment::Rack
+	include Falcon::Environment::LetsEncryptTLS
+
+	# Insert an in-memory cache in front of the application (using async-http-cache).
+	cache true
+	
+	# Connect to the supervisor for monitoring.
+	include Async::Container::Supervisor::Supervised
+end
+
+service "supervisor" do
+	include Falcon::Environment::Supervisor
+	
+	monitors do
+		[
+			MemoryMonitor.new(
+				# Check every 10 seconds:
+				interval: 10,
+				# Per-supervisor (cluster) limit:
+				total_size_limit: 1000*1024*1024,
+				# Per-process limit:
+				maximum_size_limit: 200*1024*1024
+			)
+		]
+	end
+end
+~~~
+
+These configuration blocks are evaluated using the [async-service](https://github.com/socketry/async-service) gem. The supervisor is an independent service which monitors the health of the application and can restart it if necessary. Other services like background job processors can be added to the configuration.
+
+### Environments
+
+The service blocks define configuration that is loaded by the service layer to control how the service is run. The `service ... do` block defines the service name and the environment in which it runs. Different modules can be included to provide different functionality, such as `Falcon::Environment::Rack` for Rack applications, or `Falcon::Environment::LetsEncryptTLS` for automatic TLS certificate management.
+
+### Application Configuration
+
+The environment configuration is defined in the `Falcon::Environment` module. The {ruby Falcon::Environment::Application} environment supports the generic virtual host functionality, but you can customise any parts of the configuration, e.g. to bind a production host to `localhost:3000` using plaintext HTTP/2:
+
+~~~ ruby
+#!/usr/bin/env falcon host
+# frozen_string_literal: true
+
+require "falcon/environment/rack"
+require "falcon/environment/supervisor"
+
+hostname = File.basename(__dir__)
+service hostname do
+	include Falcon::Environment::Rack
+	include Falcon::Environment::LetsEncryptTLS
+
+	endpoint do
+		Async::HTTP::Endpoint
+			.parse('http://localhost:3000')
+			.with(protocol: Async::HTTP::Protocol::HTTP2)
+	end
+end
+
+service "supervisor" do
+	include Falcon::Environment::Supervisor
+end
+~~~
+
+You can verify this is working using `nghttp -v http://localhost:3000`.
+
+#### Application Configuration Example for Heroku
+
+Building on the examples above, the following is a full configuration example for Heroku:
+
+~~~ bash
+# Procfile
+
+web: bundle exec falcon host
+~~~
+
+~~~ ruby
+# falcon.rb
+
+#!/usr/bin/env -S falcon host
+# frozen_string_literal: true
+
+require "falcon/environment/rack"
+
+hostname = File.basename(__dir__)
+
+service hostname do
+	include Falcon::Environment::Rack
+	
+	# By default, Falcon uses Etc.nprocessors to set the count, which is likely incorrect on shared hosts like Heroku.
+	# Review the following for guidance about how to find the right value for your app:
+	# https://help.heroku.com/88G3XLA6/what-is-an-acceptable-amount-of-dyno-load
+	# https://devcenter.heroku.com/articles/deploying-rails-applications-with-the-puma-web-server#workers
+	count ENV.fetch("WEB_CONCURRENCY", 1).to_i
+	
+	# If using count > 1 you may want to preload your app to reduce memory usage and increase performance:
+	preload "preload.rb"
+	
+	# The default port should be 3000, but you can change it to match your Heroku configuration.
+	port {ENV.fetch("PORT", 3000).to_i}
+	
+	# Heroku only supports HTTP/1.1 at the time of this writing. Review the following for possible updates in the future:
+	# https://devcenter.heroku.com/articles/http-routing#http-versions-supported
+	# https://github.com/heroku/roadmap/issues/34
+	endpoint do
+		Async::HTTP::Endpoint
+			.parse("http://0.0.0.0:#{port}")
+			.with(protocol: Async::HTTP::Protocol::HTTP11)
+	end
+~~~
+
+~~~ ruby
+# preload.rb
+
+# frozen_string_literal: true
+
+require_relative "config/environment"
+~~~
+
+## Falcon Virtual
+
+Falcon virtual provides a virtual host proxy and HTTP-to-HTTPS redirection for multiple applications. It is designed to be a zero-configuration deployment option, allowing you to run multiple applications on the same server.
+
+~~~ mermaid
+graph TD;
+	client[Client Browser] -->|TLS + HTTP/2 TCP| proxy["Falcon Proxy (SNI)"];
+	proxy -->|HTTP/2 UNIX PIPE| server["Application Server (Rack Compatible)"];
+~~~
+
+You need to create a `falcon.rb` configuration in the root of your applications, and start the virtual host:
+
+~~~ bash
+falcon virtual /srv/http/*/falcon.rb
+~~~
+
+By default, it binds to both HTTP and HTTPS ports, and automatically redirects HTTP requests to HTTPS. It also supports TLS SNI for resolving the certificates.
+
+See the [docker example](https://github.com/socketry/falcon-virtual-docker-example) for a complete working example.

data/context/extended-features.md

@@ -0,0 +1,13 @@
+# Extended Features
+
+This guide explains some of the extended features and functionality of Falcon.
+
+## WebSockets
+
+Falcon supports (partial and full) `rack.hijack` for both for HTTP/1 and HTTP/2 connections. You can use [async-websocket] in any controller layer to serve WebSocket connections.
+
+[async-websocket]: https://github.com/socketry/async-websocket
+
+## Early Hints
+
+Falcon supports the `rack.early_hints` API when running over HTTP/2. You can [read more about the implementation and proposed interface](https://www.codeotaku.com/journal/2019-02/falcon-early-hints/index).

data/context/getting-started.md

@@ -0,0 +1,73 @@
+# Getting Started
+
+This guide gives an overview of how to use Falcon for running Ruby web applications.
+
+## Installation
+
+Add the gem to your project:
+
+~~~ bash
+$ bundle add falcon
+~~~
+
+Or, if you prefer, install it globally:
+
+~~~ bash
+$ gem install falcon
+~~~
+
+## Core Concepts
+
+Falcon is a high-performance web server for Ruby. It is designed to be fast, lightweight, and easy to use.
+
+- **Asynchronous**: Falcon is built on top of the fiber scheduler and the [async gem](https://github.com/socketry/async) which allow it to handle thousands of connections concurrently.
+- **Rack Compatible**: Falcon is a Rack server. It can run any Rack application, including Rails, Sinatra, and Roda with no modifications.
+- **Secure**: Falcon supports TLS out of the box. It can generate self-signed certificates for localhost.
+- **HTTP/2**: Falcon is build on top of the [async-http gem](https://github.com/socketry/async-http) which supports HTTP/2. It can serve multiple requests over a single connection.
+- **WebSockets**: Falcon supports WebSockets using the [async-websocket gem](https://github.com/socketry/async-websocket) which takes advantage of Rack 3 streaming responses. You can build complex real-time applications with ease.
+
+### Rack
+
+Falcon is a Rack server. This means it can run any Rack application, including Rails, Sinatra, and Roda. It is compatible with the Rack 2 and Rack 3 specifications. Typically these applications have a `config.ru` file that defines the application. Falcon can run these applications directly:
+
+~~~ ruby
+# config.ru
+
+run do |env|
+	[200, {'Content-Type' => 'text/plain'}, ['Hello, World!']]
+end
+~~~
+
+Then run the application with:
+
+~~~ bash
+$ falcon serve
+~~~
+
+## Running a Local Server
+
+For local application development, you can use the `falcon serve` command. This will start a local server on `https://localhost:9292`. Falcon generates self-signed certificates for `localhost`. This allows you to test your application with HTTPS locally.
+
+To run on a different port:
+
+~~~ bash
+$ falcon serve --port 3000
+~~~
+
+### Unencrypted HTTP
+
+If you want to run Falcon without TLS, you can use the `--bind` option to bind to an unencrypted HTTP endpoint:
+
+~~~ bash
+$ falcon serve --bind http://localhost:3000
+~~~
+
+### Using with Rackup
+
+You can invoke Falcon via `rackup`:
+
+~~~ bash
+$ rackup --server falcon
+~~~
+
+This will run a single-threaded instance of Falcon using `http/1`. While it works fine, it's not recommended to use `rackup` with `falcon`, because performance will be limited.

data/context/how-it-works.md

@@ -0,0 +1,23 @@
+# How It Works
+
+This guide gives an overview of how Falcon handles an incoming web request.
+
+## Overview
+
+When you run `falcon serve`, Falcon creates a {ruby Falcon::Controller::Serve} which is used to create several worker threads or processes. Before starting the workers, the controller binds to an endpoint (e.g. a local unix socket, a TCP network socket, etc). The workers are spawned and receive this bound endpoint, and start accepting connections.
+
+The workers individually load a copy of your rack application. These applications are wrapped using {ruby Falcon::Adapters::Rack} which modifies the incoming {ruby Protocol::HTTP::Request} object into an `env` object suitable for your application. It also handles converting the output of your rack application `[status, headers, body]` into an instance of {ruby Falcon::Adapters::Response} which is derived from {ruby Protocol::HTTP::Response}.
+
+See the [protocol-http documentation](https://socketry.github.io/protocol-http/) for more details on how it works.
+
+## Server
+
+The server itself is mostly implemented by {ruby Async::HTTP::Server} which in turn depends on the `protocol-http` gems for the actual protocol implementations. Therefore, Falcon is primarily a bridge between the underlying protocol objects and the Rack interface.
+
+See the [async-http documentation](https://socketry.github.io/async-http/) for more details on how it works.
+
+## Protocol::Rack
+
+Falcon uses the `protocol-rack` gem to provide a Rack interface for the HTTP protocol. This allows you to run any Rack-compatible application with Falcon. However, Falcon itself is not a Rack server, but rather an HTTP server that can run Rack applications.
+
+See the [protocol-rack documentation](https://socketry.github.io/protocol-rack/) for more details on how it works.

data/context/index.yaml

@@ -0,0 +1,34 @@
+# Automatically generated context index for Utopia::Project guides.
+# Do not edit then files in this directory directly, instead edit the guides and then run `bake utopia:project:agent:context:update`.
+---
+getting-started:
+  title: Getting Started
+  order: 1
+  description: This guide gives an overview of how to use Falcon for running Ruby
+    web applications.
+rails-integration:
+  title: Rails Integration
+  order: 2
+  description: This guide explains how to host Rails applications with Falcon.
+deployment:
+  title: Deployment
+  order: 3
+  description: This guide explains how to use Falcon in production environments.
+performance-tuning:
+  title: Performance Tuning
+  order: 4
+  description: This guide explains the performance characteristics of Falcon.
+websockets:
+  title: WebSockets
+  order: 5
+  description: This guide explains how to use WebSockets with Falcon.
+interim-responses:
+  title: Interim Responses
+  order: 6
+  description: This guide explains how to use interim responses in Falcon to send
+    early hints to the client.
+how-it-works:
+  title: How It Works
+  order: 10
+  description: This guide gives an overview of how Falcon handles an incoming web
+    request.

data/context/interim-response.md

@@ -0,0 +1,19 @@
+# Interim Responses
+
+This guide explains how to use interim responses in Falcon to send early hints to the client.
+
+## Overview
+
+Interim responses allow the server to send early hints to the client before the final response is ready. This can be useful for preloading resources or providing immediate feedback. They can also be used as a response to the `expect` header, allowing the server to indicate that it is ready to process the request without waiting for the full request body.
+
+Since Rack does not currently have a specificatio for interim responses, you need to access the underlying HTTP response object directly.
+
+~~~ruby
+# config.ru
+
+run do |env|
+	if request = env["protocol.http.request"]
+		request.send_interim_response(103, [["link", "</style.css>; rel=preload; as=style"]])
+	end
+end
+~~~

data/context/interim-responses.md

@@ -0,0 +1,19 @@
+# Interim Responses
+
+This guide explains how to use interim responses in Falcon to send early hints to the client.
+
+## Overview
+
+Interim responses allow the server to send early hints to the client before the final response is ready. This can be useful for preloading resources or providing immediate feedback. They can also be used as a response to the `expect` header, allowing the server to indicate that it is ready to process the request without waiting for the full request body.
+
+Since Rack does not currently have a specificatio for interim responses, you need to access the underlying HTTP response object directly.
+
+~~~ruby
+# config.ru
+
+run do |env|
+	if request = env["protocol.http.request"]
+		request.send_interim_response(103, [["link", "</style.css>; rel=preload; as=style"]])
+	end
+end
+~~~

data/context/performance-tuning.md

@@ -0,0 +1,62 @@
+# Performance Tuning
+
+This guide explains the performance characteristics of Falcon.
+
+## Scalability
+
+Falcon uses an asynchronous event-driven reactor to provide non-blocking IO. It uses one Fiber per request, which have minimal overhead. Falcon can handle a large number of in-flight requests including long-running connections like websockets, HTTP/2 streaming, etc.
+
+- [Improving Ruby Concurrency](https://www.codeotaku.com/journal/2018-06/improving-ruby-concurrency/index#performance) – Comparison of Falcon and Puma.
+
+### Falcon Benchmark
+
+The [falcon-benchmark] suite looks at how various servers respond to different levels of concurrency across several sample applications.
+
+[falcon-benchmark]: https://github.com/socketry/falcon-benchmark
+
+## Memory Usage
+
+Falcon uses [async-container] to start multiple copies of your application. Each instance of your application is isolated by default for maximum fault-tolerance. However, this can lead to increased memory usage. Preloading parts of your application reduce this overhead and in addition can improve instance start-up time. To understand your application memory usage, you should use [process-metrics] which take into account memory shared between processes.
+
+[async-container]: https://github.com/socketry/async-container
+[process-metrics]: https://github.com/socketry/process-metrics
+
+### Preloading
+
+Falcon offers two mechanisms for preloading code.
+
+#### Preloading Gems
+
+By default, falcon will load all gems in the `preload` group:
+
+~~~ ruby
+# In gems.rb:
+
+source "https://rubygems.org"
+
+group :preload do
+	# List any gems you want to be pre-loaded into the falcon process before forking.
+end
+~~~
+
+#### Preloading Files
+
+Create a file in your application called `preload.rb`. You can put this file anywhere in your application.
+
+##### Falcon Serve
+
+`falcon serve` has a `--preload` option which accepts the path to this file.
+
+##### Falcon Host
+
+`falcon.rb` applications may have a `preload` configuration option.
+
+## System Limitations
+
+If you are expecting to handle many simultaneous connections, please ensure you configure your file limits correctly.
+
+~~~
+Errno::EMFILE: Too many open files - accept(2)
+~~~
+
+This means that your system is limiting the number of files that can be opened by falcon. Please check the `ulimit` of your system and set it appropriately.

data/context/rails-integration.md

@@ -0,0 +1,90 @@
+# Rails Integration
+
+This guide explains how to host Rails applications with Falcon.
+
+**We strongly recommend using the latest stable release of Rails with Falcon.**
+
+We now recommend using the `Falcon::Rails` gem for Rails integration. This gem provides a simple way to configure Falcon as the web server for your Rails application, and includes many conveniences for running Rails with Falcon.
+
+~~~
+> bundle add falcon-rails
+~~~
+
+It also includes detailed documentation for [common tasks and configurations](https://socketry.github.io/falcon-rails/).
+
+## Usage
+
+Because Rails apps are built on top of Rack, they are compatible with Falcon.
+
+1. Add `gem "falcon"` to your `Gemfile` and perhaps remove `gem "puma"` once you are satisfied with the change.
+2. Run `falcon serve` to start a local development server.
+
+Falcon assumes HTTPS by default (so that browsers can use HTTP2). To run under HTTP in development you can bind it to an explicit scheme, host and port:
+
+~~~ bash
+falcon serve -b http://localhost:3000
+~~~
+
+### Self-signed Development Certificates
+
+The [localhost gem](https://github.com/socketry/localhost) is used to generate self-signed certificates for local development. This allows you to run Falcon with HTTPS in development without needing to set up a real certificate authority. However, you must still install the development certificate to avoid security warnings in your browser:
+
+~~~bash
+> bundle exec bake localhost:install
+~~~
+
+### Production
+
+The `falcon serve` command is only intended to be used for local development. We recommend you use `falcon host` for production deployments.
+
+#### Falcon Host Configuration File
+
+Create a `falcon.rb` file in the root of your Rails application. This file will be used to configure the Falcon server for production. The following example binds HTTP/1 to port 3000 as is common for Rails applications:
+
+~~~ ruby
+#!/usr/bin/env -S falcon-host
+# frozen_string_literal: true
+
+require "falcon/environment/rack"
+
+hostname = File.basename(__dir__)
+
+service hostname do
+	include Falcon::Environment::Rack
+	
+	# This file will be loaded in the main process before forking.
+	preload "preload.rb"
+	
+	# Default to port 3000 unless otherwise specified.
+	port {ENV.fetch("PORT", 3000).to_i}
+	
+	# Default to HTTP/1.1.
+	endpoint do
+		Async::HTTP::Endpoint
+			.parse("http://0.0.0.0:#{port}")
+			.with(protocol: Async::HTTP::Protocol::HTTP11)
+	end
+end
+~~~
+
+#### Preloading Rails
+
+Preloading is a technique used to load your Rails application into memory before forking worker processes. This can significantly improve performance by reducing the time it takes to start each worker.
+
+~~~ ruby
+# frozen_string_literal: true
+
+require_relative "config/environment"
+~~~
+
+#### Running the Production Server
+
+To run the production server, make sure your `falcon.rb` is executable and then run it:
+
+~~~ bash
+> bundle exec falcon.rb
+~~~
+
+## Isolation Level
+
+Rails provides the ability to change its internal isolation level from threads (default) to fibers. When you use `falcon` with Rails, it will automatically set the isolation level to fibers as Falcon provides the appropriate Railtie.

data/context/websockets.md

@@ -0,0 +1,23 @@
+# WebSockets
+
+This guide explains how to use WebSockets with Falcon.
+
+## Overview
+
+Falcon supports WebSockets using the [async-websocket gem](https://github.com/socketry/async-websocket). This allows you to build real-time applications that can handle bidirectional communication between the server and clients.
+
+~~~ruby
+# config.ru
+
+require "async/websocket/adapter/rack"
+
+run do |env|
+	Async::WebSocket::Adapters::Rack.open(env, protocols: ['ws']) do |connection|
+		# Simple echo server:
+		while message = connection.read
+			connection.write(message)
+			connection.flush
+		end
+	end or [200, {}, ["Hello World"]]
+end
+~~~

data/lib/falcon/version.rb

@@ -4,5 +4,5 @@
 # Copyright, 2017-2025, by Samuel Williams.
 
 module Falcon
-	VERSION = "0.52.0"
+	VERSION = "0.52.1"
 end

data/readme.md

@@ -29,22 +29,32 @@ Please visit [Socketry.io](https://socketry.io) to register and subscribe.
 
 Please see the [project documentation](https://socketry.github.io/falcon/) for more details.
 
-  - [Getting Started](https://socketry.github.io/falcon/guides/getting-started/index) - This guide explains how to use Falcon for Ruby web application development.
+  - [Getting Started](https://socketry.github.io/falcon/guides/getting-started/index) - This guide gives an overview of how to use Falcon for running Ruby web applications.
 
   - [Rails Integration](https://socketry.github.io/falcon/guides/rails-integration/index) - This guide explains how to host Rails applications with Falcon.
 
   - [Deployment](https://socketry.github.io/falcon/guides/deployment/index) - This guide explains how to use Falcon in production environments.
 
-  - [Extended Features](https://socketry.github.io/falcon/guides/extended-features/index) - This guide explains some of the extended features and functionality of Falcon.
-
   - [Performance Tuning](https://socketry.github.io/falcon/guides/performance-tuning/index) - This guide explains the performance characteristics of Falcon.
 
+  - [WebSockets](https://socketry.github.io/falcon/guides/websockets/index) - This guide explains how to use WebSockets with Falcon.
+
+  - [Interim Responses](https://socketry.github.io/falcon/guides/interim-responses/index) - This guide explains how to use interim responses in Falcon to send early hints to the client.
+
   - [How It Works](https://socketry.github.io/falcon/guides/how-it-works/index) - This guide gives an overview of how Falcon handles an incoming web request.
 
 ## Releases
 
 Please see the [project releases](https://socketry.github.io/falcon/releases/index) for all releases.
 
+### v0.52.0
+
+  - Modernized codebase and dropped support for Ruby v3.1.
+  - Improved Rails integration documentation.
+  - Added extra logging of `RUBY_DESCRIPTION`.
+  - Minor documentation improvements.
+  - Agent context is now available, via the [`agent-context` gem](https://github.com/ioquatix/agent-context).
+
 ### v0.51.0
 
   - Introduce <code class="language-ruby">Falcon::Environment::Server\#make\_server</code> which gives you full control over the server creation process.

data/releases.md

@@ -1,5 +1,13 @@
 # Releases
 
+## v0.52.0
+
+  - Modernized codebase and dropped support for Ruby v3.1.
+  - Improved Rails integration documentation.
+  - Added extra logging of `RUBY_DESCRIPTION`.
+  - Minor documentation improvements.
+  - Agent context is now available, via the [`agent-context` gem](https://github.com/ioquatix/agent-context).
+
 ## v0.51.0
 
   - Introduce {ruby Falcon::Environment::Server\#make\_server} which gives you full control over the server creation process.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: falcon
 version: !ruby/object:Gem::Version
-  version: 0.52.0
+  version: 0.52.1
 platform: ruby
 authors:
 - Samuel Williams
@@ -241,6 +241,16 @@ files:
 - bake/falcon/supervisor.rb
 - bin/falcon
 - bin/falcon-host
+- context/deployment.md
+- context/extended-features.md
+- context/getting-started.md
+- context/how-it-works.md
+- context/index.yaml
+- context/interim-response.md
+- context/interim-responses.md
+- context/performance-tuning.md
+- context/rails-integration.md
+- context/websockets.md
 - lib/falcon.rb
 - lib/falcon/command.rb
 - lib/falcon/command/host.rb
@@ -301,7 +311,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A fast, asynchronous, rack-compatible web server.
 test_files: []