Class: Fino::Redis::Adapter

Inherits:
Object
  • Object
show all
Includes:
Adapter
Defined in:
lib/fino/redis/adapter.rb

Constant Summary collapse

DEFAULT_REDIS_NAMESPACE = 
"fino"
SETTINGS_NAMESPACE = 
"s"
CONVERSIONS_NAMESPACE = 
"c"
CONVERSIONS_KEYS_NAMESPACE = 
"ck"
CONVERSIONS_TTL =

7 days

7 * 24 * 60 * 60
PERSISTED_SETTINGS_KEYS_REDIS_KEY = 
"psl"
SCOPE_PREFIX = 
"s"
VARIANT_PREFIX = 
"v"
VALUE_KEY = 
"v"

Instance Method Summary collapse

Constructor Details

#initialize(redis, namespace: DEFAULT_REDIS_NAMESPACE) ⇒ Adapter

Returns a new instance of Adapter.



18
19
20
21
 
# File 'lib/fino/redis/adapter.rb', line 18

def initialize(redis, namespace: DEFAULT_REDIS_NAMESPACE)
  @redis = redis
  @redis_namespace = namespace
end

Instance Method Details

#clear(setting_key) ⇒ Object 



60
61
62
63
64
65
66
67
 
# File 'lib/fino/redis/adapter.rb', line 60

def clear(setting_key)
  _, cleared = redis.multi do |r|
    r.del(redis_key_for(setting_key))
    r.srem(build_redis_key(PERSISTED_SETTINGS_KEYS_REDIS_KEY), setting_key)
  end

  cleared == 1
end

#clear_ab_testing_conversions(setting_key) ⇒ Object 



119
120
121
122
123
124
125
126
127
128
 
# File 'lib/fino/redis/adapter.rb', line 119

def clear_ab_testing_conversions(setting_key)
  tracking_key = build_redis_key(CONVERSIONS_KEYS_NAMESPACE, setting_key)
  keys = redis.smembers(tracking_key)
  return unless keys.any?

  redis.pipelined do |pipeline|
    keys.each { |key| pipeline.del(key) }
    pipeline.del(tracking_key)
  end
end

#fetch_raw_overrides_from(raw_adapter_data) ⇒ Object 



73
74
75
76
77
78
79
80
 
# File 'lib/fino/redis/adapter.rb', line 73

def fetch_raw_overrides_from(raw_adapter_data)
  raw_adapter_data.each_with_object({}) do |(key, value), memo|
    next unless key.start_with?("#{SCOPE_PREFIX}/")

    scope = key.delete_prefix("#{SCOPE_PREFIX}/").delete_suffix("/#{VALUE_KEY}")
    memo[scope] = value
  end
end

#fetch_raw_variants_from(raw_adapter_data) ⇒ Object 



82
83
84
85
86
87
88
89
90
 
# File 'lib/fino/redis/adapter.rb', line 82

def fetch_raw_variants_from(raw_adapter_data)
  raw_adapter_data.each_with_object([]) do |(key, value), memo|
    next unless key.start_with?("#{VARIANT_PREFIX}/")

    percentage = key.split("/", 3)[1]

    memo << { percentage: percentage.to_f, value: value }
  end
end

#fetch_value_from(raw_adapter_data) ⇒ Object 



69
70
71
 
# File 'lib/fino/redis/adapter.rb', line 69

def fetch_value_from(raw_adapter_data)
  raw_adapter_data.key?(VALUE_KEY) ? raw_adapter_data.delete(VALUE_KEY) : Fino::EMPTINESS
end

#read(setting_key) ⇒ Object 



23
24
25
 
# File 'lib/fino/redis/adapter.rb', line 23

def read(setting_key)
  redis.hgetall(redis_key_for(setting_key))
end

#read_ab_testing_conversions(setting_definition, variants) ⇒ Object 



109
110
111
112
113
114
115
116
117
 
# File 'lib/fino/redis/adapter.rb', line 109

def read_ab_testing_conversions(setting_definition, variants)
  keys = variants.map { |v| build_redis_key(CONVERSIONS_NAMESPACE, setting_definition.key, v.id) }

  results = redis.pipelined do |pipeline|
    keys.each { |key| pipeline.zrange(key, 0, -1, withscores: true) }
  end

  variants.zip(results).to_h
end

#read_multi(setting_keys) ⇒ Object 



27
28
29
30
31
32
33
 
# File 'lib/fino/redis/adapter.rb', line 27

def read_multi(setting_keys)
  keys = setting_keys.map { |setting_key| redis_key_for(setting_key) }

  redis.pipelined do |pipeline|
    keys.each { |key| pipeline.hgetall(key) }
  end
end

#read_persisted_setting_keys ⇒ Object 



56
57
58
 
# File 'lib/fino/redis/adapter.rb', line 56

def read_persisted_setting_keys
  redis.smembers(build_redis_key(PERSISTED_SETTINGS_KEYS_REDIS_KEY))
end

#record_ab_testing_conversion(setting_definition, variant, scope, time) ⇒ Object

A/B testing analysis



96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/fino/redis/adapter.rb', line 96

def record_ab_testing_conversion(setting_definition, variant, scope, time)
  timestamp_ms = (time.to_f * 1000).to_i

  key = build_redis_key(CONVERSIONS_NAMESPACE, setting_definition.key, variant.id)
  tracking_key = build_redis_key(CONVERSIONS_KEYS_NAMESPACE, setting_definition.key)

  redis.pipelined do |pipeline|
    pipeline.zadd(key, timestamp_ms, scope.to_s, nx: true)
    pipeline.expire(key, CONVERSIONS_TTL)
    pipeline.sadd(tracking_key, key)
  end
end

#write(setting_definition, value, overrides, variants) ⇒ Object 



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/fino/redis/adapter.rb', line 35

def write(setting_definition, value, overrides, variants)
  serialize_value = ->(raw_value) { setting_definition.serialize(raw_value) }

  hash = { VALUE_KEY => serialize_value.call(value) }

  overrides.each do |scope, value|
    hash["#{SCOPE_PREFIX}/#{scope}/#{VALUE_KEY}"] = serialize_value.call(value)
  end

  variants.each do |variant|
    next if variant.value == Fino::AbTesting::Variant::CONTROL_VALUE

    hash["#{VARIANT_PREFIX}/#{variant.percentage}/#{VALUE_KEY}"] = serialize_value.call(variant.value)
  end

  redis.multi do |r|
    r.mapped_hreplace(redis_key_for(setting_definition.key), hash)
    r.sadd(build_redis_key(PERSISTED_SETTINGS_KEYS_REDIS_KEY), setting_definition.key)
  end
end