Module: Semian::Redis

Includes:
Adapter
Defined in:
lib/semian/redis.rb

Constant Summary collapse

ResourceBusyError = 
::Redis::ResourceBusyError
CircuitOpenError = 
::Redis::CircuitOpenError
ResolveError = 
::Redis::ResolveError

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Adapter

#clear_semian_resource, #semian_resource

Class Method Details

.included(base) ⇒ Object

The naked methods are exposed as ‘raw_query` and `raw_connect` for instrumentation purpose



67
68
69
70
71
72
73
 
# File 'lib/semian/redis.rb', line 67

def self.included(base)
  base.send(:alias_method, :raw_io, :io)
  base.send(:remove_method, :io)

  base.send(:alias_method, :raw_connect, :connect)
  base.send(:remove_method, :connect)
end

Instance Method Details

#connect ⇒ Object 



91
92
93
94
95
96
97
98
99
100
 
# File 'lib/semian/redis.rb', line 91

def connect
  acquire_semian_resource(adapter: :redis, scope: :connection) do
    begin
      raw_connect
    rescue SocketError, RuntimeError => e
      raise ResolveError.new(semian_identifier) if dns_resolve_failure?(e.cause || e)
      raise
    end
  end
end

#io(&block) ⇒ Object 



83
84
85
86
87
88
89
 
# File 'lib/semian/redis.rb', line 83

def io(&block)
  acquire_semian_resource(adapter: :redis, scope: :query) do
    reply = raw_io(&block)
    raise_if_out_of_memory(reply)
    reply
  end
end

#semian_identifier ⇒ Object 



75
76
77
78
79
80
81
 
# File 'lib/semian/redis.rb', line 75

def semian_identifier
  @semian_identifier ||= begin
    name = semian_options && semian_options[:name]
    name ||= "#{location}/#{db}"
    :"redis_#{name}"
  end
end

#with_resource_timeout(temp_timeout) ⇒ Object 



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/semian/redis.rb', line 102

def with_resource_timeout(temp_timeout)
  timeout = options[:timeout]
  connect_timeout = options[:connect_timeout]
  read_timeout = options[:read_timeout]
  write_timeout = options[:write_timeout]

  begin
    connection.timeout = temp_timeout if connected?
    options[:timeout] = Float(temp_timeout),
    options[:connect_timeout] = Float(temp_timeout)
    options[:read_timeout] = Float(temp_timeout)
    options[:write_timeout] = Float(temp_timeout)
    yield
  ensure
    options[:timeout] = timeout
    options[:connect_timeout] = connect_timeout
    options[:read_timeout] = read_timeout
    options[:write_timeout] = write_timeout
    connection.timeout = self.timeout if connected?
  end
end