poollint 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fa4fde7f8ba603b4f035a7fe7a42b6cb1f33fc0bdbb9c6cfb06639f6937d2872
+  data.tar.gz: 446e24c4f6f786f375fb1cf55ea72dbfaaffdd595e60e3fd02c32635be1805cc
+SHA512:
+  metadata.gz: 8b7177024e6100f4c55a8051552dd29741f816c7f9807ab2caa93c7079693ae0ded56b615f53708af05a19c9cf1a624dad6b85dd40c9891739515dfc8a7756a2
+  data.tar.gz: f2062b21d8b487a87cc14904d55119160092bcf21976548a6f5070571fe58f1a9ed30c0cba19bf9f74ca49b4b9d1967bc8c00e44c7a56a3eddd938858efe9a08

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,226 @@
+# PoolLint
+
+PoolLint detects PostgreSQL and MySQL session state that leaks through
+an Active Record connection pool.
+
+A request can run `SET ROLE tenant_a`, acquire a session advisory lock, or
+change a custom GUC. On MySQL it can change `time_zone` or retain a `GET_LOCK`.
+If the request forgets to restore that state, Active Record returns the
+connection to the pool and a later request silently inherits it.
+PoolLint records suspicious SQL and verifies the connection at a pool
+boundary before reporting the leak.
+
+The gem observes and reports. It never resets application state automatically.
+
+## Requirements
+
+| Ruby | Rails / Active Record | PostgreSQL | MySQL |
+| --- | --- | --- | --- |
+| 3.2–3.4 | 7.1 | 16 (`pg`) | 8.4 (`mysql2`, `trilogy`) |
+| 3.2–3.4 | 7.2 | 16 (`pg`) | 8.4 (`mysql2`, `trilogy`) |
+| 3.2–3.4 | 8.0 | 16 (`pg`) | 8.4 (`mysql2`, `trilogy`) |
+
+CI runs both databases and both MySQL adapters for every supported Ruby/Rails
+combination. Rails main runs as an allowed-to-fail compatibility signal.
+Unsupported adapters, including SQLite3, are left untouched.
+
+## Installation
+
+Add the gem to a Rails application:
+
+```ruby
+gem "poollint", "~> 0.1.0"
+```
+
+The Railtie installs the SQL subscriber and connection callbacks during boot.
+
+## Configuration
+
+```ruby
+# config/initializers/poollint.rb
+PoolLint.configure do |config|
+  config.inspection_point = :checkout
+  config.mode = :log
+  config.inspection_timeout = 0.25
+  config.check_probability = 1.0
+  config.rebaseline_after_report = true
+
+  config.watched_settings = PoolLint::DEFAULT_PG_SETTINGS
+  config.mysql_watched_settings = PoolLint::DEFAULT_MYSQL_SETTINGS
+  config.track_custom_gucs = true
+  config.check_advisory_locks = true
+  config.suspicion_log_size = 20
+
+  # A hash allows selected values.
+  config.allowed_settings = {
+    "application_name" => /\Amy-app-/,
+    "statement_timeout" => ->(value) { value.to_i <= 500 }
+  }
+  # Or use ["application_name"] to ignore every value for named settings.
+
+  config.ignore_if = ->(report) { report.setting_changes.empty? }
+end
+```
+
+Defaults have two axes:
+
+| Environment | Inspection point | Report mode |
+| --- | --- | --- |
+| `test` | `:checkin` | `:raise` |
+| all others | `:checkout` | `:log` |
+
+`:raise` raises `PoolLint::LeakedSessionState`
+(`PoolLint::LeakDetected` remains an alias). At `:checkin`, that mode
+is intended for tests because callback exceptions can prevent a connection
+from returning to the available queue.
+
+`check_probability` samples dirty inspections only. Initial baseline capture is
+never sampled. `inspection_timeout` is expressed in seconds. PostgreSQL applies
+it with `SET LOCAL statement_timeout` in a short transaction; MySQL applies a
+`MAX_EXECUTION_TIME` hint to inspector queries. The former millisecond accessor
+remains available as `inspection_timeout_ms`.
+
+### Inspection point trade-offs
+
+| Point | Report timing | Pool mutex | Intended use |
+| --- | --- | --- | --- |
+| `:checkout` | next borrower | inspector runs outside it | production default |
+| `:checkin` | leaking borrower | held for the full inspection | tests and controlled environments |
+
+Checkout reporting is delayed until the connection is borrowed again. This is
+the cost of avoiding database queries while Active Record holds the pool mutex.
+Selecting `:checkin` outside test emits a startup warning. Runtime evidence for
+Rails 7.1, 7.2, and 8.0 is recorded in
+[`docs/pool_locking.md`](docs/pool_locking.md).
+
+## Detection scope
+
+| Database | Detected | Not detected |
+| --- | --- | --- |
+| PostgreSQL | session `SET` and `RESET` changes | `SET LOCAL` and `SET TRANSACTION` |
+| PostgreSQL | `SET ROLE` and `SET SESSION AUTHORIZATION` | transaction-scoped advisory locks |
+| PostgreSQL | custom GUCs such as `myapp.tenant_id` | temporary tables and `LISTEN` registrations |
+| PostgreSQL | session advisory locks owned by the connection backend | prepared statements |
+| MySQL | configured `@@SESSION` variables | unconfigured session variables |
+| MySQL | `GET_LOCK` retained by the current connection | transaction metadata locks |
+
+SQL classification accepts leading Query Logs or Marginalia comments, lowercase
+keywords, and line breaks. Inspector SQL is guarded against re-entry. Suspicious
+SQL is truncated to 200 characters and kept in a bounded per-connection ring.
+
+`DEFAULT_PG_SETTINGS` contains `role`, `session_authorization`, `search_path`,
+`statement_timeout`, `lock_timeout`, `idle_in_transaction_session_timeout`, and
+`default_transaction_read_only`. Set `track_custom_gucs = false` to stop adding
+settings discovered from SQL to that list, or `check_advisory_locks = false` to
+skip `pg_locks` inspection.
+
+For a setting present in the initial baseline, the current value is compared
+with that baseline. For a dynamically discovered setting absent from the
+baseline, the current value is compared with PostgreSQL's `reset_val`. Custom
+GUCs are not rows in `pg_settings`; their empty post-`RESET` value is treated as
+the reset state. `role` and `session_authorization` are read with
+`current_setting` because PostgreSQL 16 does not expose them in `pg_settings`.
+
+Advisory lock inspection is restricted to `pid = pg_backend_pid()`. Locks owned
+by another pooled connection cannot be attributed to the inspected connection
+and are ignored.
+
+`DEFAULT_MYSQL_SETTINGS` contains `sql_mode`, `time_zone`,
+`transaction_isolation`, `transaction_read_only`, `lock_wait_timeout`, and
+`max_execution_time`. Replace or extend `mysql_watched_settings` to inspect
+other session variables. Variable names are validated before they are used in
+inspector SQL.
+
+MySQL user-level locks are confirmed through
+`performance_schema.metadata_locks`, restricted to the thread whose
+`PROCESSLIST_ID` is `CONNECTION_ID()`. Confirmed entries carry
+`confidence: :confirmed`. If the metadata lock instrument is disabled or access
+to Performance Schema is denied, PoolLint falls back to the observed
+balance of `GET_LOCK`, `RELEASE_LOCK`, and `RELEASE_ALL_LOCKS`, and reports
+`confidence: :inferred`. Inferred results can be conservative because SQL
+observation cannot know whether `GET_LOCK` succeeded or resolve a dynamically
+computed lock name.
+
+## Suppression and notifications
+
+Suppress reports emitted within a known-safe block:
+
+```ruby
+PoolLint.suppress do
+  ActiveRecord::Base.connection_pool.with_connection do |connection|
+    # A report emitted while borrowing or returning this connection is suppressed.
+  end
+end
+```
+
+Suppression does not disable dirty tracking. `ignore_if` receives the complete
+report and can apply an application-specific policy.
+
+Every non-ignored report emits `leaked_state.poollint` through
+`ActiveSupport::Notifications`. Its payload contains `inspection_point`,
+`setting_changes`, `advisory_locks`, `user_level_locks`, and `suspicions`.
+Monitoring systems can subscribe without a hard dependency:
+
+```ruby
+ActiveSupport::Notifications.subscribe("leaked_state.poollint") do |event|
+  SecurityEvents.publish("database_session_leak", event.payload)
+end
+```
+
+When Kannuki is already loaded, PoolLint best-effort matches leaked
+numeric advisory keys against `Kannuki::LockManager.current_locks` and adds the
+human-readable lock name to the report. Kannuki is never required or loaded by
+PoolLint.
+
+## PgBouncer
+
+Session state is meaningful only while a client is attached to the same
+PostgreSQL backend. With PgBouncer session pooling, use the gem normally and
+also configure PgBouncer's server reset behavior. Transaction or statement
+pooling can switch backends between statements; application session settings
+and session advisory locks are unsuitable in those modes, and reports may not
+describe a single stable backend session.
+
+## Failure safety
+
+Unexpected timeout, disconnection, malformed response, logger, or policy
+exceptions are converted to warnings so checkout/checkin can continue.
+`PoolLint::LeakDetected` in explicit `:raise` mode is the sole intended
+exception. Inspection stores a constant amount of state per connection: a
+baseline, dirty keys, and a bounded suspicion ring.
+
+## Performance
+
+The non-dirty boundary path performs no SQL. From a source checkout, run the
+local benchmark with:
+
+```sh
+bundle exec ruby benchmark/boundary_overhead.rb
+```
+
+On 2026-07-28, a local Apple Silicon / Ruby 4.0 run measured the non-dirty
+boundary at **3.40 million iterations/second (293.8 ns/iteration)**. CI verifies
+behavior rather than asserting a machine-specific timing threshold.
+
+## Development
+
+```sh
+bundle install
+docker compose up -d --wait postgres mysql
+bundle exec rspec
+bundle exec appraisal rails-7.1 rspec
+bundle exec appraisal rails-7.2 rspec
+bundle exec appraisal rails-8.0 rspec
+bundle exec rubocop
+bundle exec rake build
+```
+
+`DATABASE_URL` overrides the default local URL
+`postgresql://postgres:postgres@127.0.0.1:55432/poollint_test`.
+MySQL defaults to `root:mysql@127.0.0.1:33306/poollint_test`;
+override it with `MYSQL_HOST`, `MYSQL_PORT`, `MYSQL_DATABASE`,
+`MYSQL_USERNAME`, and `MYSQL_PASSWORD`.
+
+## License
+
+PoolLint is available under the MIT License.

data/docs/pool_locking.md

@@ -0,0 +1,59 @@
+# Active Record pool callback spike
+
+This document records the behavior that determines PoolLint's default
+inspection point. The results were measured against PostgreSQL 16 on 2026-07-28
+with `scripts/spikes/pool_locking.rb`.
+
+## Results
+
+| Active Record | `_run_checkout_callbacks` owns pool mutex | `_run_checkin_callbacks` owns pool mutex | checkout callback exception | checkin callback exception |
+| --- | --- | --- | --- | --- |
+| 7.1.6 | no | yes | connection removed; next checkout succeeds | connection stranded; next checkout times out |
+| 7.2.3 | no | yes | connection removed; next checkout succeeds | connection stranded; next checkout times out |
+| 8.0.2 | no | yes | connection removed; next checkout succeeds | connection stranded; next checkout times out |
+
+From a source checkout, run an individual measurement with:
+
+```sh
+AR_VERSION=7.2.3 ruby scripts/spikes/pool_locking.rb
+```
+
+The source layout agrees with the runtime probe. In all three versions,
+`ConnectionPool#checkin` enters the pool's `synchronize` block before invoking
+`_run_checkin_callbacks`. `checkout_and_verify` invokes
+`_run_checkout_callbacks` after `acquire_connection` has left that critical
+section.
+
+## Decision
+
+The default inspection point is `:checkout`.
+
+- Inspector queries at checkout do not hold the pool mutex.
+- A slow inspection delays only the borrower receiving that connection.
+- A leak is reported on the next borrow instead of at the end of the leaking
+  borrow.
+
+`:checkin` remains available for tests and tightly controlled environments. It
+runs under the pool mutex, so inspector latency blocks pool operations. All
+unexpected inspector errors must be converted to warnings at either inspection
+point. Raising from a checkin callback can strand the connection before it is
+returned to the available queue.
+
+## PostgreSQL setting spike
+
+PostgreSQL 16 does not expose `role` or `session_authorization` as rows in
+`pg_settings`. Both are readable with `current_setting`:
+
+```sql
+SELECT current_setting('role'),
+       current_setting('session_authorization');
+```
+
+The inspector therefore reads requested settings through `current_setting` and
+left joins `pg_settings` for `reset_val`. This keeps ordinary GUCs in one batch
+while supporting the two special settings and custom GUCs.
+
+For an ordinary GUC, `reset_val` remains the session default across
+`SET`/`RESET`. A custom GUC is absent from `pg_settings`; after `RESET`,
+`current_setting(name, true)` returns an empty string. The inspector treats an
+empty custom value as its reset state.

data/docs/releasing.md

@@ -0,0 +1,21 @@
+# Releasing
+
+1. Start PostgreSQL and MySQL with
+   `docker compose up -d --wait postgres mysql`.
+2. Run `bundle exec rake`, then run the specs under every Appraisal:
+   `rails-7.1`, `rails-7.2`, `rails-8.0`, and `rails-main`.
+3. Run the MySQL-tagged specs once with `MYSQL_ADAPTER=mysql2` and once with
+   `MYSQL_ADAPTER=trilogy`.
+4. Confirm the supported Ruby/Rails matrix and Rails main signal in CI.
+5. Review the version in
+   `lib/poollint/version.rb`.
+6. Build and inspect the package with `bundle exec rake build` and
+   `gem specification pkg/poollint-X.Y.Z.gem files`.
+7. Install the built package into an isolated directory and verify
+   `require "poollint"`.
+8. Commit the version, create an annotated `vX.Y.Z` tag, and push
+   the commit and tag.
+9. Publish with MFA using `gem push pkg/poollint-X.Y.Z.gem`.
+
+Publishing is intentionally a separate authenticated action. Do not publish
+from an unreviewed working tree.

data/lib/poollint/allowed_settings.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module PoolLint
+  class AllowedSettings
+    UNCONFIGURED = Object.new.freeze
+
+    def initialize(rules)
+      @rules = normalize(rules)
+    end
+
+    def allow?(name, value)
+      rule = @rules.fetch(name) { @rules.fetch(name.to_sym, UNCONFIGURED) }
+
+      case rule
+      when UNCONFIGURED then false
+      when nil, true then true
+      when Proc then rule.call(value)
+      when Regexp then rule.match?(value.to_s)
+      when Array then rule.include?(value)
+      else rule == value
+      end
+    end
+
+    private
+
+    def normalize(rules)
+      return rules unless rules.is_a?(Array)
+
+      rules.to_h { |name| [name.to_s, true] }
+    end
+  end
+end

data/lib/poollint/configuration.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module PoolLint
+  DEFAULT_PG_SETTINGS = %w[
+    role
+    session_authorization
+    search_path
+    statement_timeout
+    lock_timeout
+    idle_in_transaction_session_timeout
+    default_transaction_read_only
+  ].freeze
+  DEFAULT_MYSQL_SETTINGS = %w[
+    sql_mode
+    time_zone
+    transaction_isolation
+    transaction_read_only
+    lock_wait_timeout
+    max_execution_time
+  ].freeze
+
+  class Configuration
+    INSPECTION_POINTS = %i[checkout checkin].freeze
+    MODES = %i[log raise].freeze
+
+    attr_reader :environment
+    attr_accessor :allowed_settings,
+                  :check_advisory_locks,
+                  :check_probability,
+                  :ignore_if,
+                  :inspection_point,
+                  :inspection_timeout,
+                  :logger,
+                  :mode,
+                  :mysql_watched_settings,
+                  :rebaseline_after_report,
+                  :suspicion_log_size,
+                  :track_custom_gucs,
+                  :watched_settings
+
+    def initialize(environment: nil)
+      @environment = environment || default_environment
+      test_environment = @environment.to_s == "test"
+      @allowed_settings = []
+      @check_advisory_locks = true
+      @check_probability = 1.0
+      @ignore_if = nil
+      @inspection_point = test_environment ? :checkin : :checkout
+      @inspection_timeout = 0.25
+      @logger = nil
+      @mode = test_environment ? :raise : :log
+      @mysql_watched_settings = DEFAULT_MYSQL_SETTINGS.dup
+      @rebaseline_after_report = true
+      @suspicion_log_size = 20
+      @track_custom_gucs = true
+      @watched_settings = DEFAULT_PG_SETTINGS.dup
+    end
+
+    def inspection_timeout_ms
+      (inspection_timeout * 1000).round
+    end
+
+    def inspection_timeout_ms=(value)
+      self.inspection_timeout = Float(value) / 1000
+    end
+
+    def suspicion_limit
+      suspicion_log_size
+    end
+
+    def suspicion_limit=(value)
+      self.suspicion_log_size = value
+    end
+
+    def test_environment?
+      environment.to_s == "test"
+    end
+
+    def validate!
+      validate_choices!
+      validate_flags!
+      validate_probability!
+      validate_positive_number!(:inspection_timeout, inspection_timeout)
+      validate_positive_integer!(:suspicion_log_size, suspicion_log_size)
+      validate_ignore_if!
+      validate_allowed_settings!
+      self.watched_settings = Array(watched_settings).map { |name| normalize_setting(name) }.uniq
+      self.mysql_watched_settings = normalize_mysql_settings
+      self
+    end
+
+    private
+
+    def default_environment
+      return Rails.env.to_s if defined?(Rails) && Rails.respond_to?(:env)
+
+      ENV.fetch("RAILS_ENV", ENV.fetch("RACK_ENV", nil))
+    end
+
+    def normalize_setting(name)
+      name.to_s.downcase
+    end
+
+    def normalize_mysql_settings
+      Array(mysql_watched_settings).map do |name|
+        normalized = normalize_setting(name)
+        unless normalized.match?(/\A[a-z_][a-z0-9_]*\z/)
+          raise ArgumentError, "invalid MySQL session variable: #{name}"
+        end
+
+        normalized
+      end.uniq
+    end
+
+    def validate_allowed_settings!
+      return if allowed_settings.is_a?(Array) || allowed_settings.is_a?(Hash)
+
+      raise ArgumentError, "allowed_settings must be an Array or Hash"
+    end
+
+    def validate_boolean!(name, value)
+      return if [true, false].include?(value)
+
+      raise ArgumentError, "#{name} must be true or false"
+    end
+
+    def validate_choices!
+      validate_member!(:inspection_point, inspection_point, INSPECTION_POINTS)
+      validate_member!(:mode, mode, MODES)
+    end
+
+    def validate_flags!
+      validate_boolean!(:check_advisory_locks, check_advisory_locks)
+      validate_boolean!(:rebaseline_after_report, rebaseline_after_report)
+      validate_boolean!(:track_custom_gucs, track_custom_gucs)
+    end
+
+    def validate_ignore_if!
+      return if ignore_if.nil? || ignore_if.respond_to?(:call)
+
+      raise ArgumentError, "ignore_if must be callable"
+    end
+
+    def validate_member!(name, value, allowed)
+      return if allowed.include?(value)
+
+      choices = allowed.join(", ")
+      raise ArgumentError, "#{name} must be one of: #{choices}"
+    end
+
+    def validate_positive_integer!(name, value)
+      return if value.is_a?(Integer) && value.positive?
+
+      raise ArgumentError, "#{name} must be a positive Integer"
+    end
+
+    def validate_positive_number!(name, value)
+      return if value.is_a?(Numeric) && value.positive?
+
+      raise ArgumentError, "#{name} must be a positive number"
+    end
+
+    def validate_probability!
+      valid = check_probability.is_a?(Numeric) && check_probability.between?(0.0, 1.0)
+      return if valid
+
+      raise ArgumentError, "check_probability must be between 0.0 and 1.0"
+    end
+  end
+end

data/lib/poollint/connection_state.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "set"
+require "thread"
+
+module PoolLint
+  class ConnectionState
+    IVAR = :@poollint_state
+
+    def self.attach(connection, state)
+      connection.instance_variable_set(IVAR, state)
+    end
+
+    def self.attached?(connection, state)
+      connection.instance_variable_get(IVAR).equal?(state)
+    end
+
+    def self.fetch(connection, suspicion_limit:)
+      connection.instance_variable_get(IVAR) ||
+        attach(connection, new(suspicion_limit: suspicion_limit))
+    end
+
+    def self.remove(connection)
+      connection.remove_instance_variable(IVAR) if connection.instance_variable_defined?(IVAR)
+    end
+
+    def initialize(suspicion_limit:)
+      @mutex = Mutex.new
+      @suspicions = SuspicionLog.new(limit: suspicion_limit)
+      reset!
+    end
+
+    def baseline?
+      @mutex.synchronize { !@baseline.nil? }
+    end
+
+    def baseline
+      @mutex.synchronize { @baseline }
+    end
+
+    def capture_baseline(snapshot)
+      @mutex.synchronize do
+        @baseline = snapshot
+        clear_tracking
+      end
+    end
+
+    def dirty?
+      @mutex.synchronize { @dirty }
+    end
+
+    def mark_dirty(kind:, setting:, sql:, call_site:, **tracking)
+      @mutex.synchronize do
+        @dirty = true
+        @monitored_settings << setting if setting && tracking.fetch(:monitor_setting, true)
+        track_user_lock(tracking[:lock_operation], tracking[:lock_name])
+        @suspicions.add(
+          Suspicion.new(
+            kind: kind,
+            setting: setting,
+            sql: sql,
+            call_site: call_site,
+            lock_operation: tracking[:lock_operation],
+            lock_name: tracking[:lock_name]
+          )
+        )
+      end
+    end
+
+    def inferred_user_locks
+      @mutex.synchronize { @inferred_user_locks.dup }
+    end
+
+    def monitored_settings
+      @mutex.synchronize { @monitored_settings.to_a }
+    end
+
+    def reset!
+      @mutex.synchronize do
+        @baseline = nil
+        clear_tracking
+      end
+    end
+
+    def suspicions
+      @mutex.synchronize { @suspicions.entries }
+    end
+
+    def finish_inspection(snapshot:, rebaseline:)
+      @mutex.synchronize do
+        @baseline = snapshot if rebaseline
+        clear_tracking
+      end
+    end
+
+    private
+
+    def clear_tracking
+      @dirty = false
+      @inferred_user_locks = {}
+      @monitored_settings = Set.new
+      @suspicions.clear
+    end
+
+    def track_user_lock(operation, name)
+      case operation
+      when :acquire
+        key = name || "<dynamic>"
+        @inferred_user_locks[key] = @inferred_user_locks.fetch(key, 0) + 1
+      when :release
+        release_user_lock(name)
+      when :release_all
+        @inferred_user_locks.clear
+      end
+    end
+
+    def release_user_lock(name)
+      return unless name && @inferred_user_locks.key?(name)
+
+      remaining = @inferred_user_locks.fetch(name) - 1
+      if remaining.positive?
+        @inferred_user_locks[name] = remaining
+      else
+        @inferred_user_locks.delete(name)
+      end
+    end
+  end
+end

data/lib/poollint/errors.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module PoolLint
+  class Error < StandardError; end
+
+  class InspectionTimeout < Error; end
+
+  class LeakedSessionState < Error
+    attr_reader :report
+
+    def initialize(report)
+      @report = report
+      super(report.to_s)
+    end
+  end
+
+  LeakDetected = LeakedSessionState
+end