Class: Pgtk::Impatient

Inherits:
Object
  • Object
show all
Defined in:
lib/pgtk/impatient.rb

Overview

Impatient is a decorator for Pool that enforces timeouts on all database operations. It ensures that SQL queries don’t run indefinitely, which helps prevent application hangs and resource exhaustion when database operations are slow or stalled.

This class implements the same interface as Pool but wraps each database operation in a timeout block. If a query exceeds the specified timeout, it raises a Timeout::Error exception, allowing the application to handle slow queries gracefully.

Basic usage:

# Create and configure a regular pool
pool = Pgtk::Pool.new(wire).start(4)

# Wrap the pool in an impatient decorator with a 2-second timeout
impatient = Pgtk::Impatient.new(pool, 2)

# Execute queries with automatic timeout enforcement
begin
  impatient.exec('SELECT * FROM large_table WHERE complex_condition')
rescue Timeout::Error
  puts "Query timed out after 2 seconds"
end

# Transactions also enforce timeouts on each query
begin
  impatient.transaction do |t|
    t.exec('UPDATE large_table SET processed = true')
    t.exec('DELETE FROM queue WHERE processed = true')
  end
rescue Timeout::Error
  puts "Transaction timed out"
end

# Combining with Spy for timeout monitoring
spy = Pgtk::Spy.new(impatient) do |sql, duration|
  puts "Query completed in #{duration} seconds: #{sql}"
end

# Now queries are both timed and monitored
spy.exec('SELECT * FROM users')
Author

Yegor Bugayenko ([email protected])

Copyright

Copyright © 2019-2025 Yegor Bugayenko

License

MIT

Defined Under Namespace

Classes: TooSlow

Instance Method Summary collapse

Constructor Details

#initialize(pool, timeout, *off) ⇒ Impatient

Constructor.

Parameters:

  • pool (Pgtk::Pool) —

    The pool to decorate

  • timeout (Integer) —

    Timeout in seconds for each SQL query

  • off (Array<Regex>) —

    List of regex to exclude queries from checking



63
64
65
66
67
 
# File 'lib/pgtk/impatient.rb', line 63

def initialize(pool, timeout, *off)
  @pool = pool
  @timeout = timeout
  @off = off
end

Instance Method Details

#exec(sql, *args) ⇒ Array

Execute a SQL query with a timeout.

Parameters:

  • sql (String) —

    The SQL query with params inside (possibly)

  • args (Array) —

    List of arguments

Returns:

  • (Array) —

    Result rows

Raises:

  • (Timeout::Error) —

    If the query takes too long



82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/pgtk/impatient.rb', line 82

def exec(sql, *args)
  return @pool.exec(sql, *args) if @off.any? { |re| re.match?(sql) }
  start = Time.now
  begin
    Timeout.timeout(@timeout) do
      @pool.exec(sql, *args)
    end
  rescue Timeout::Error
    raise TooSlow, [
      'SQL query',
      ("with #{args.count} arguments" unless args.empty?),
      'stopped after',
      start.ago,
      'of waiting'
    ].compact.join(' ')
  end
end

#transaction {|Pgtk::Impatient| ... } ⇒ Object

Run a transaction with a timeout for each query.

Yields:

Returns:

  • (Object) —

    Result of the block



104
105
106
107
108
 
# File 'lib/pgtk/impatient.rb', line 104

def transaction
  @pool.transaction do |t|
    yield Pgtk::Impatient.new(t, @timeout)
  end
end

#version ⇒ String

Get the version of PostgreSQL server.

Returns:

  • (String) —

    Version of PostgreSQL server



72
73
74
 
# File 'lib/pgtk/impatient.rb', line 72

def version
  @pool.version
end