rage-rb 1.19.2 → 1.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c49338e5b69de7d3c5667af08785441a4988710da64e84946023a660cc31560
-  data.tar.gz: 841f4c508fb3d0739fd912967d370f5b40e69dbe8089727ea8cc56b123abd9ff
+  metadata.gz: a730f86d3b220732b6359247b4a0f3a44d72dd80aef857553f9daabb530753e6
+  data.tar.gz: 68254c6dcad99882a9bd4996051ac35713cad21f62405de59b311f01afc77616
 SHA512:
-  metadata.gz: 73c04963af90446e29b52564020c42048735a3df8a17e071dd744f139094e68a64cabf66396433b05dd1cd51fa1b91374fe06133754b2d802171641cf2f44956
-  data.tar.gz: d7561754ef307415e7d848e9ac0fc2731c03281285664eafd3c2865ebc7234bb03826c22cb803e05d48aaa3c4fce05d568a13b199f4d5ee5eb8d2613ba13c4b9
+  metadata.gz: 118c2ad29d1f3f2f91a8c2d153c020cc053b2e975ca876f3e0b50e18f2707a639193762c3cf2f7a25685b0b609bfa83225c19507d0f4b8f8ff4b7ca926026e51
+  data.tar.gz: 6c988a0e2bd16f12ad614c5e40fd4fb6d5441ad1adc0135253f52e4a971b3614fa00b5b5627d04bd37140aa55079e8bacd939970e7ac4f594dff929a6ef64be0

data/.rspec

@@ -1,3 +1,4 @@
 --format documentation
 --color
 --require spec_helper
+--exclude-pattern 'spec/ext/**/**_spec.rb'

data/Appraisals

@@ -0,0 +1,19 @@
+appraise "active_record_7_0" do
+  gem "activerecord", "~> 7.0.0"
+end
+
+appraise "active_record_7_1" do
+  gem "activerecord", "~> 7.1.0"
+end
+
+appraise "active_record_7_2" do
+  gem "activerecord", "~> 7.2.0"
+end
+
+appraise "active_record_8_0" do
+  gem "activerecord", "~> 8.0.0"
+end
+
+appraise "active_record_8_1" do
+  gem "activerecord", "~> 8.1.0"
+end

data/CHANGELOG.md

@@ -1,6 +1,20 @@
 ## [Unreleased]
 
-## [1.19.2] - 2025-01-06
+## [1.20.0] - 2026-01-20
+
+### Added
+
+- Add `Rage::Telemetry` (#186).
+- Add the `Response#status` method. (#191).
+- [Deferred] Expose deferred metadata (#188).
+- [Deferred] Support deferred middleware (#184).
+- Ensure compatibility with `Rack::Events` (#180).
+
+### Changed
+
+- Refactor the implementation of `rescue_from` in `Rage::Events` (#185).
+
+## [1.19.2] - 2026-01-06
 
 ### Changed
 

data/CODE_OF_CONDUCT.md

@@ -2,7 +2,7 @@
 
 ## Our Pledge
 
-We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, caste, color, religion, or sexual identity and orientation.
 
 We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
 
@@ -10,22 +10,19 @@ We pledge to act and interact in ways that contribute to an open, welcoming, div
 
 Examples of behavior that contributes to a positive environment for our community include:
 
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the overall community
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+- Focusing on what is best not just for us as individuals, but for the overall community
 
 Examples of unacceptable behavior include:
 
-* The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
-  address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
+- The use of sexualized language or imagery, and sexual attention or advances of any kind
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others’ private information, such as a physical or email address, without their explicit permission
+- Other conduct which could reasonably be considered inappropriate in a professional setting
 
 ## Enforcement Responsibilities
 
@@ -67,14 +64,13 @@ Community leaders will follow these Community Impact Guidelines in determining t
 
 ### 4. Permanent Ban
 
-**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.
 
 **Consequence**: A permanent ban from any sort of public interaction within the community.
 
 ## Attribution
 
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
-available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.1, available at https://www.contributor-covenant.org/version/2/1/code_of_conduct.html.
 
 Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
 

data/Gemfile

@@ -12,6 +12,8 @@ gem "yard"
 gem "rubocop", "~> 1.65.0", require: false
 
 group :test do
+  gem "ostruct"
+  gem "benchmark"
   gem "activesupport"
   gem "http"
   gem "pg"
@@ -23,4 +25,5 @@ group :test do
   gem "websocket-client-simple"
   gem "prism"
   gem "redis-client"
+  gem "appraisal", "~> 2.5"
 end

data/README.md

@@ -6,74 +6,66 @@
 ![Tests](https://github.com/rage-rb/rage/actions/workflows/main.yml/badge.svg)
 ![Ruby Requirement](https://img.shields.io/badge/Ruby-3.2%2B-%23f40000)
 
-Rage is a high-performance framework compatible with Rails, featuring [WebSocket](https://github.com/rage-rb/rage/wiki/WebSockets-guide) support and automatic generation of [OpenAPI](https://github.com/rage-rb/rage/wiki/OpenAPI-Guide) documentation for your APIs. The framework is built on top of [Iodine](https://github.com/rage-rb/iodine) and is based on the following design principles:
+Rage is a high-performance Ruby web framework that combines the developer experience of Rails with the scalability of fiber-based concurrency. Designed for API-first applications, it allows you to handle massive traffic loads using standard synchronous Ruby code - no complex async/await syntax required.
 
-* **Rails compatible API** - Rails' API is clean, straightforward, and simply makes sense. It was one of the reasons why Rails was so successful in the past.
+If you love Rails but need better performance for I/O-heavy workloads, Rage provides the perfect balance: familiar conventions, low overhead, and a commitment to stability.
 
-* **High performance** - some think performance is not a major metric for a framework, but it's not true. Poor performance is a risk, and in today's world, companies refuse to use risky technologies.
+## Why Rage?
 
-* **API-only** - separation of concerns is one of the most fundamental principles in software development. Backend and frontend are very different layers with different goals and paths to those goals. Separating BE code from FE code results in a much more sustainable architecture compared with classic Rails monoliths.
+Building high-performance APIs in Ruby shouldn't mean abandoning the conventions you know. Rage gives you Rails-like controllers, routing, and patterns, but runs on **fiber-based concurrency** that makes your application naturally non-blocking. When your code waits on database queries, HTTP calls, or other I/O, Rage automatically handles thousands of other requests instead of sitting idle.
 
-* **Acceptance of modern Ruby** - the framework includes a fiber scheduler, which means your code never blocks while waiting on I/O.
+Rage was built to solve the performance and stability gaps that often drive teams to migrate away from Ruby, providing a modern engine that keeps the ecosystem competitive.
+
+**Key capabilities:**
+
+- **Rails compatibility** - Familiar controller API, routing DSL, and conventions. Migrate gradually or start fresh.
+- **True concurrency** - Fiber-based architecture handles I/O without threads, locks, or async/await syntax. Your code looks synchronous but runs concurrently.
+- **Zero-dependency WebSockets** - Action Cable-compatible real-time features that work out-of-the-box without Redis, even in multi-process mode.
+- **Auto-generated OpenAPI** - Documentation generated from your controllers using simple comment tags.
+- **In-process Background jobs** - A durable, persistent queue that runs inside your app process. No Redis or separate worker processes required.
+- **Built-in Observability** - Track and measure application behavior with `Rage::Telemetry`. Integrate with external monitoring platforms or build custom observability solutions.
+- **Stable and focused** - Our goal is that the task "Upgrade Rage" never appears in your ticketing system. We focus strictly on APIs, maintain long-term deprecation cycles, and ensure that most updates are as simple as a `bundle update`.
+
+Rage is API-only by design. Modern applications benefit from clear separation between backend and frontend, and Rage focuses exclusively on doing APIs well.
 
 ## Installation
 
 Install the gem:
+
 ```
 $ gem install rage-rb
 ```
 
 Create a new app:
+
 ```
 $ rage new my_app
 ```
 
 Switch to your new application and install dependencies:
+
 ```
 $ cd my_app
 $ bundle
 ```
 
 Start up the server and visit http://localhost:3000.
+
 ```
 $ rage s
 ```
 
 Start coding!
 
-## Getting Started
-
-This gem is designed to be a drop-in replacement for Rails in API mode. Public API is expected to fully match Rails.
-
-A Rage application can operate in two modes:
-
-* **Rails Mode**: Integrate Rage into an existing Rails application to improve throughput and better handle traffic spikes. For more information, see [Rails Integration](https://github.com/rage-rb/rage/wiki/Rails-integration).
-* **Standalone Mode**: Build high-performance services with minimal setup using Rage. To get started, run `rage new --help` for more details.
-
-Check out in-depth API docs for more information:
-
-- [Controller API](https://rage-rb.pages.dev/RageController/API)
-- [Routing API](https://rage-rb.pages.dev/Rage/Router/DSL/Handler)
-- [Fiber API](https://rage-rb.pages.dev/Fiber)
-- [Logger API](https://rage-rb.pages.dev/Rage/Logger)
-- [Configuration API](https://rage-rb.pages.dev/Rage/Configuration)
-
-Built-in middleware:
-- [CORS](https://rage-rb.pages.dev/Rage/Cors)
-- [RequestId](https://rage-rb.pages.dev/Rage/RequestId)
+## How It Works
 
-Also, see the following guides:
+Rage runs each request in a separate fiber. When your code performs I/O operations - HTTP requests, database queries, file reads - the fiber automatically pauses, and Rage processes other requests. When the I/O completes, the fiber resumes exactly where it left off.
 
-- [Rails Integration](https://github.com/rage-rb/rage/wiki/Rails-integration)
-- [RSpec Integration](https://github.com/rage-rb/rage/wiki/RSpec-integration)
-- [WebSockets Guide](https://github.com/rage-rb/rage/wiki/WebSockets-guide)
-- [Background Tasks Guide](https://github.com/rage-rb/rage/wiki/Background-Tasks-Guide)
-
-If you are a first-time contributor, make sure to check the [overview doc](https://github.com/rage-rb/rage/blob/master/OVERVIEW.md) that shows how Rage's core components interact with each other.
+This happens transparently. You write normal Ruby code, and Rage handles the concurrency.
 
 ### Example
 
-A sample controller could look like this:
+Here's a controller that fetches data from an external API:
 
 ```ruby
 require "net/http"
@@ -98,9 +90,9 @@ class PagesController < RageController::API
 end
 ```
 
-Apart from `RageController::API` as a parent class, this is mostly a regular Rails controller. However, the main difference is under the hood - Rage runs every request in a separate fiber. During the call to `Net::HTTP.get`, the fiber is automatically paused, enabling the server to process other requests. Once the HTTP request is finished, the fiber will be resumed, potentially allowing to process hundreds of requests simultaneously.
+This looks like a standard Rails controller, and it is - except during `Net::HTTP.get`, Rage automatically pauses this fiber and processes other requests. When the HTTP call completes, Rage resumes exactly where it left off. This happens automatically for HTTP requests, PostgreSQL, MySQL, and other I/O operations.
 
-To make this controller work, we would also need to update `config/routes.rb`. In this case, the file would look the following way:
+The routes are equally familiar:
 
 ```ruby
 Rage.routes.draw do
@@ -108,9 +100,9 @@ Rage.routes.draw do
 end
 ```
 
-:information_source: **Note**: Rage will automatically pause a fiber and continue to process other fibers on HTTP, PostgreSQL, and MySQL calls. Calls to `Thread.join` and `Ractor.join` will also automatically pause the current fiber.
+### Parallel Execution
 
-Additionally, `Fiber.await` can be used to run several requests in parallel:
+Need to make multiple I/O calls? Use `Fiber.await` to run them concurrently:
 
 ```ruby
 require "net/http"
@@ -127,11 +119,31 @@ class PagesController < RageController::API
 end
 ```
 
-:information_source: **Note**: When using `Fiber.await`, it is important to wrap every argument into a fiber using `Fiber.schedule`.
+Instead of waiting for each request sequentially, Rage executes them concurrently and waits for all to complete.
+
+## Two Ways to Use Rage
+
+**Standalone**: Create new services with `rage new`. You get a clean project structure, CLI tools, and everything needed to build high-performance APIs from scratch.
+
+**Rails Integration**: Add Rage to existing Rails applications for gradual migration. Use Rage for new endpoints or high-traffic routes while keeping the rest of your Rails app unchanged. See the [Rails Integration guide](https://rage-rb.dev/docs/rails) for details.
+
+## Documentation
+
+- [Getting Started](https://rage-rb.dev/docs/intro/) - Core concepts and setup
+- [Controllers](https://rage-rb.dev/docs/controllers/) - Request handling and callbacks
+- [Routing](https://rage-rb.dev/docs/routing/) - RESTful routes and namespaces
+- [WebSockets](https://rage-rb.dev/docs/websockets/) - Real-time communication
+- [OpenAPI](https://rage-rb.dev/docs/openapi/) - Auto-generated documentation
+- [Background Jobs](https://rage-rb.dev/docs/deferred/) - In-process queue system
+- [API Reference](https://rage-rb.dev/api/) - Detailed API documentation
+
+For contributors, check the [architecture doc](https://github.com/rage-rb/rage/blob/main/ARCHITECTURE.md) to understand how Rage's components work together.
 
-## Benchmarks
+## Performance
 
-#### Hello World
+Rage's fiber-based architecture delivers high throughput with minimal overhead. By stripping away the "framework tax", Rage gives your team more leeway to write slow-but-maintainable Ruby code without compromising the end-user experience.
+
+#### Simple JSON responses
 
 ```ruby
 class BenchmarksController < ApplicationController
@@ -141,13 +153,12 @@ class BenchmarksController < ApplicationController
 end
 ```
 
-![Requests per second](https://github.com/user-attachments/assets/a7f864ae-0dfb-4628-a420-265a10d8591d)
+![Requests per second](https://github.com/user-attachments/assets/7bb783f8-5d1b-4e7d-b14d-dafe370d1acc)
 
-#### Waiting on I/O
 
-```ruby
-require "net/http"
+#### I/O-bound operations
 
+```ruby
 class BenchmarksController < ApplicationController
   def index
     Net::HTTP.get(URI("<endpoint-that-responds-in-one-second>"))
@@ -156,9 +167,9 @@ class BenchmarksController < ApplicationController
 end
 ```
 
-![Time to complete 100 requests](https://github.com/user-attachments/assets/4f4feda3-bd88-43d8-8999-268534c2f9de)
+![Time to complete 100 requests](https://github.com/user-attachments/assets/5155a65f-2f11-4303-b5e4-a74d3d123c16)
 
-#### Using ActiveRecord
+#### Database Queries
 
 ```ruby
 class BenchmarksController < ApplicationController
@@ -168,21 +179,7 @@ class BenchmarksController < ApplicationController
 end
 ```
 
-![Requests per second](https://github.com/user-attachments/assets/04678788-0034-4db4-9582-d0bc16fd9e28)
-
-## Upcoming releases
-
-Status | Changes
--- | ------------
-:white_check_mark: | ~~Gem configuration by env.<br>Add `skip_before_action`.<br>Add `rescue_from`.<br>Router updates:<br>&emsp;• make the `root` helper work correctly with `scope`;<br>&emsp;• support the `defaults` option;~~
-:white_check_mark: | ~~CLI updates:<br>&emsp;• `routes` task;<br>&emsp;• `console` task;<br>Support the `:if` and `:unless` options in `before_action`.<br>Allow to set response headers.~~
-:white_check_mark: | ~~Expose the `params` object.<br>Support header authentication with `authenticate_with_http_token`.<br>Router updates:<br>&emsp;• add the `resources` route helper;<br>&emsp;• add the `namespace` route helper;~~
-:white_check_mark:  | ~~Add request logging.~~
-:white_check_mark: | ~~Automatic code reloading in development with Zeitwerk.~~
-:white_check_mark: | ~~Support conditional get with `etag` and `last_modified`.~~
-:white_check_mark: | ~~Expose the `cookies` and `session` objects.~~
-:white_check_mark: | ~~Implement Iodine-based equivalent of Action Cable.~~
-⏳ | Expose the `send_data` and `send_file` methods.
+![Requests per second-2](https://github.com/user-attachments/assets/06f64a08-316f-4b24-ba2d-39ac395366aa)
 
 ## Development
 
@@ -192,7 +189,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/rage-rb/rage. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/rage-rb/rage/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/rage-rb/rage. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/rage-rb/rage/blob/main/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -200,4 +197,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Rage project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/rage-rb/rage/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Rage project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/rage-rb/rage/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -6,3 +6,17 @@ require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec)
 
 task default: :spec
+
+task :appraise do |_, args|
+  ext_versions = `appraisal list`.split("\n")
+
+  # Since we want to test against the main branch separately, we remove it from the list.
+  ext_versions.reject! { |version| version.end_with?("_head") }
+
+  ext_versions.each do |ext_version|
+    puts ">> Appraising #{ext_version}"
+
+    gem_name = ext_version.sub(/_\d+(_\d+)*$/, "")
+    system "bundle exec appraisal #{ext_version} rspec spec/ext/#{gem_name}/"
+  end
+end

data/lib/rage/all.rb

@@ -33,6 +33,9 @@ require_relative "middleware/fiber_wrapper"
 require_relative "middleware/cors"
 require_relative "middleware/reloader"
 require_relative "middleware/request_id"
+require_relative "middleware/body_finalizer"
+
+require_relative "telemetry/telemetry"
 
 if defined?(Sidekiq)
   require_relative "sidekiq_session"

data/lib/rage/cable/cable.rb

@@ -43,11 +43,13 @@ module Rage::Cable
     accept_response = [0, __protocol.protocol_definition, []]
 
     application = ->(env) do
-      if env["rack.upgrade?"] == :websocket
-        env["rack.upgrade"] = handler
-        accept_response
-      else
-        [426, { "connection" => "upgrade", "upgrade" => "websocket" }, []]
+      Rage::Telemetry.tracer.span_cable_websocket_handshake(env:) do
+        if env["rack.upgrade?"] == :websocket
+          env["rack.upgrade"] = handler
+          accept_response
+        else
+          [426, { "connection" => "upgrade", "upgrade" => "websocket" }, []]
+        end
       end
     end
 
@@ -133,8 +135,10 @@ module Rage::Cable
   # @example
   #   Rage.cable.broadcast("chat", { message: "A new member has joined!" })
   def self.broadcast(stream, data)
-    __protocol.broadcast(stream, data)
-    __adapter&.publish(stream, data)
+    Rage::Telemetry.tracer.span_cable_stream_broadcast(stream:) do
+      __protocol.broadcast(stream, data)
+      __adapter&.publish(stream, data)
+    end
 
     true
   end

data/lib/rage/cable/channel.rb

@@ -372,7 +372,9 @@ class Rage::Cable::Channel
 
   # @private
   def __run_action(action_name, data = nil)
-    self.class.__prepared_actions[action_name].call(self, data)
+    Rage::Telemetry.tracer.span_cable_action_process(channel: self, action: action_name, data:) do
+      self.class.__prepared_actions[action_name].call(self, data)
+    end
   end
 
   # @private
@@ -382,6 +384,9 @@ class Rage::Cable::Channel
     @__identified_by = identified_by
   end
 
+  # @private
+  attr_reader :__connection
+
   # Get the params hash passed in during the subscription process.
   #
   # @return [Hash{Symbol=>String,Array,Hash,Numeric,NilClass,TrueClass,FalseClass}]

data/lib/rage/cable/connection.rb

@@ -32,6 +32,10 @@ class Rage::Cable::Connection
   def connect
   end
 
+  # @private
+  def disconnect
+  end
+
   # Reject the WebSocket connection.
   def reject_unauthorized_connection
     @rejected = true

data/lib/rage/cable/router.rb

@@ -14,14 +14,18 @@ class Rage::Cable::Router
   # @return [true] if the connection was accepted
   # @return [false] if the connection was rejected
   def process_connection(connection)
-    cable_connection = @connection_class.new(connection.env)
-    cable_connection.connect
+    env = connection.env
+
+    cable_connection = @connection_class.new(env)
+    Rage::Telemetry.tracer.span_cable_connection_process(connection: cable_connection, action: :connect, env:) do
+      cable_connection.connect
+    end
 
     if cable_connection.rejected?
       Rage.logger.debug { "An unauthorized connection attempt was rejected" }
     else
-      connection.env["rage.identified_by"] = cable_connection.__identified_by_map
-      connection.env["rage.cable"] = {}
+      env["rage.identified_by"] = cable_connection.__identified_by_map
+      env["rage.cable"] = {}
     end
 
     !cable_connection.rejected?
@@ -105,12 +109,15 @@ class Rage::Cable::Router
   #
   # @param connection [Rage::Cable::WebSocketConnection] the connection object
   def process_disconnection(connection)
-    connection.env["rage.cable"]&.each do |_, channel|
+    env = connection.env
+
+    env["rage.cable"]&.each do |_, channel|
       channel.__run_action(:unsubscribed)
     end
 
-    if @connection_can_disconnect
-      cable_connection = @connection_class.new(connection.env, connection.env["rage.identified_by"])
+    cable_connection = @connection_class.new(env, env["rage.identified_by"])
+
+    Rage::Telemetry.tracer.span_cable_connection_process(connection: cable_connection, action: :disconnect, env:) do
       cable_connection.disconnect
     end
   end
@@ -132,7 +139,5 @@ class Rage::Cable::Router
       puts "WARNING: Could not find the RageCable connection class! All connections will be accepted by default."
       Rage::Cable::Connection
     end
-
-    @connection_can_disconnect = @connection_class.method_defined?(:disconnect)
   end
 end