Class: PoolLint::ConnectionState

Inherits:
Object
  • Object
show all
Defined in:
lib/poollint/connection_state.rb

Constant Summary collapse

IVAR = 
:@poollint_state

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(suspicion_limit:) ⇒ ConnectionState

Returns a new instance of ConnectionState.



27
28
29
30
31
 
# File 'lib/poollint/connection_state.rb', line 27

def initialize(suspicion_limit:)
  @mutex = Mutex.new
  @suspicions = SuspicionLog.new(limit: suspicion_limit)
  reset!
end

Class Method Details

.attach(connection, state) ⇒ Object 



10
11
12
 
# File 'lib/poollint/connection_state.rb', line 10

def self.attach(connection, state)
  connection.instance_variable_set(IVAR, state)
end

.attached?(connection, state) ⇒ Boolean

Returns:

  • (Boolean) 


14
15
16
 
# File 'lib/poollint/connection_state.rb', line 14

def self.attached?(connection, state)
  connection.instance_variable_get(IVAR).equal?(state)
end

.fetch(connection, suspicion_limit:) ⇒ Object 



18
19
20
21
 
# File 'lib/poollint/connection_state.rb', line 18

def self.fetch(connection, suspicion_limit:)
  connection.instance_variable_get(IVAR) ||
    attach(connection, new(suspicion_limit: suspicion_limit))
end

.remove(connection) ⇒ Object 



23
24
25
 
# File 'lib/poollint/connection_state.rb', line 23

def self.remove(connection)
  connection.remove_instance_variable(IVAR) if connection.instance_variable_defined?(IVAR)
end

Instance Method Details

#baseline ⇒ Object 



37
38
39
 
# File 'lib/poollint/connection_state.rb', line 37

def baseline
  @mutex.synchronize { @baseline }
end

#baseline? ⇒ Boolean

Returns:

  • (Boolean) 


33
34
35
 
# File 'lib/poollint/connection_state.rb', line 33

def baseline?
  @mutex.synchronize { !@baseline.nil? }
end

#capture_baseline(snapshot) ⇒ Object 



41
42
43
44
45
46
 
# File 'lib/poollint/connection_state.rb', line 41

def capture_baseline(snapshot)
  @mutex.synchronize do
    @baseline = snapshot
    clear_tracking
  end
end

#dirty? ⇒ Boolean

Returns:

  • (Boolean) 


48
49
50
 
# File 'lib/poollint/connection_state.rb', line 48

def dirty?
  @mutex.synchronize { @dirty }
end

#finish_inspection(snapshot:, rebaseline:) ⇒ Object 



89
90
91
92
93
94
 
# File 'lib/poollint/connection_state.rb', line 89

def finish_inspection(snapshot:, rebaseline:)
  @mutex.synchronize do
    @baseline = snapshot if rebaseline
    clear_tracking
  end
end

#inferred_user_locks ⇒ Object 



70
71
72
 
# File 'lib/poollint/connection_state.rb', line 70

def inferred_user_locks
  @mutex.synchronize { @inferred_user_locks.dup }
end

#mark_dirty(kind:, setting:, sql:, call_site:, **tracking) ⇒ Object 



52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/poollint/connection_state.rb', line 52

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

#monitored_settings ⇒ Object 



74
75
76
 
# File 'lib/poollint/connection_state.rb', line 74

def monitored_settings
  @mutex.synchronize { @monitored_settings.to_a }
end

#reset! ⇒ Object 



78
79
80
81
82
83
 
# File 'lib/poollint/connection_state.rb', line 78

def reset!
  @mutex.synchronize do
    @baseline = nil
    clear_tracking
  end
end

#suspicions ⇒ Object 



85
86
87
 
# File 'lib/poollint/connection_state.rb', line 85

def suspicions
  @mutex.synchronize { @suspicions.entries }
end