Class: PostHog::FeatureFlagsPoller

Inherits:
Object
  • Object
show all
Includes:
Logging, Utils
Defined in:
lib/posthog/feature_flags.rb

Constant Summary

Constants included from Utils

Utils::UTC_OFFSET_WITHOUT_COLON, Utils::UTC_OFFSET_WITH_COLON

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Utils

#date_in_iso8601, #datetime_in_iso8601, #formatted_offset, #is_valid_regex, #isoify_dates, #isoify_dates!, #seconds_to_utc_offset, #stringify_keys, #symbolize_keys, #symbolize_keys!, #time_in_iso8601, #uid

Methods included from Logging

included, #logger

Constructor Details

#initialize(polling_interval, personal_api_key, project_api_key, host) ⇒ FeatureFlagsPoller

Returns a new instance of FeatureFlagsPoller.



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/posthog/feature_flags.rb', line 20

def initialize(polling_interval, personal_api_key, project_api_key, host)
  @polling_interval = polling_interval || 30
  @personal_api_key = personal_api_key
  @project_api_key = project_api_key
  @host = host
  @feature_flags = Concurrent::Array.new
  @group_type_mapping = Concurrent::Hash.new
  @loaded_flags_successfully_once = Concurrent::AtomicBoolean.new

  @task =
    Concurrent::TimerTask.new(
      execution_interval: polling_interval,
    ) { _load_feature_flags }

  # If no personal API key, disable local evaluation & thus polling for definitions
  if @personal_api_key.nil?
    logger.info "No personal API key provided, disabling local evaluation"
    @loaded_flags_successfully_once.make_true
  else
    # load once before timer
    load_feature_flags
    @task.execute
  end
end

Class Method Details

.match_property(property, property_values) ⇒ Object

Class methods



157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
 
# File 'lib/posthog/feature_flags.rb', line 157

def self.match_property(property, property_values)
  # only looks for matches where key exists in property_values
  # doesn't support operator is_not_set
  
  PostHog::Utils.symbolize_keys! property
  PostHog::Utils.symbolize_keys! property_values

  key = property[:key].to_sym
  value = property[:value]
  operator = property[:operator] || 'exact'

  if !property_values.key?(key)
    raise InconclusiveMatchError.new("Property #{key} not found in property_values")
  elsif operator == 'is_not_set'
    raise InconclusiveMatchError.new("Operator is_not_set not supported")
  end

  override_value = property_values[key]

  case operator
  when 'exact'
    value.is_a?(Array) ? value.include?(override_value) : value == override_value
  when 'is_not'
    value.is_a?(Array) ? !value.include?(override_value) : value != override_value
  when'is_set'
    property_values.key?(key)
  when 'icontains'
    override_value.to_s.downcase.include?(value.to_s.downcase)
  when 'not_icontains'
    !override_value.to_s.downcase.include?(value.to_s.downcase)
  when 'regex'
    PostHog::Utils.is_valid_regex(value.to_s) && !Regexp.new(value.to_s).match(override_value.to_s).nil?
  when 'not_regex'
    PostHog::Utils.is_valid_regex(value.to_s) && Regexp.new(value.to_s).match(override_value.to_s).nil?
  when 'gt'
    override_value.class == value.class && override_value > value
  when 'gte'
    override_value.class == value.class && override_value >= value
  when 'lt'
    override_value.class == value.class && override_value < value
  when 'lte'
    override_value.class == value.class && override_value <= value
  else
    logger.error "Unknown operator: #{operator}"
    false
  end
end

Instance Method Details

#get_all_flags(distinct_id, groups = {}, person_properties = {}, group_properties = {}, only_evaluate_locally = false) ⇒ Object 



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/posthog/feature_flags.rb', line 120

def get_all_flags(distinct_id, groups = {}, person_properties = {}, group_properties = {}, only_evaluate_locally = false)
  # returns a string hash of all flags

  # make sure they're loaded on first run
  load_feature_flags

  response = {}
  fallback_to_decide = @feature_flags.empty?

  @feature_flags.each do |flag|
    begin
      response[flag[:key]] = _compute_flag_locally(flag, distinct_id, groups, person_properties, group_properties)
    rescue InconclusiveMatchError => e
      fallback_to_decide = true
    rescue StandardError => e
      logger.error "Error computing flag locally: #{e}."
      fallback_to_decide = true
    end
  end

  if fallback_to_decide && !only_evaluate_locally
    begin
      flags = get_feature_variants(distinct_id, groups, person_properties, group_properties)
      response = {**response, **flags}
    rescue StandardError => e
      logger.error "Error computing flag remotely: #{e}"
    end
  end
  response
end

#get_feature_flag(key, distinct_id, groups = {}, person_properties = {}, group_properties = {}, only_evaluate_locally = false) ⇒ Object 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/posthog/feature_flags.rb', line 69

def get_feature_flag(key, distinct_id, groups = {}, person_properties = {}, group_properties = {}, only_evaluate_locally = false)
  # make sure they're loaded on first run
  load_feature_flags

  symbolize_keys! groups
  symbolize_keys! person_properties
  symbolize_keys! group_properties

  group_properties.each do |key, value|
    symbolize_keys! value
  end

  response = nil
  feature_flag = nil

  @feature_flags.each do |flag|
    if key == flag[:key]
      feature_flag = flag
      break
    end
  end

  if !feature_flag.nil?
    begin
      response = _compute_flag_locally(feature_flag, distinct_id, groups, person_properties, group_properties)
      logger.debug "Successfully computed flag locally: #{key} -> #{response}"
    rescue InconclusiveMatchError => e
      logger.debug "Failed to compute flag #{key} locally: #{e}"
    rescue StandardError => e
      logger.error "Error computing flag locally: #{e}. #{e.backtrace.join("\n")}"
    end
  end

  flag_was_locally_evaluated = !response.nil?

  if !flag_was_locally_evaluated && !only_evaluate_locally
    begin
      flags = get_feature_variants(distinct_id, groups, person_properties, group_properties)
      response = flags[key]
      if response.nil?
        response = false
      end
      logger.debug "Successfully computed flag remotely: #{key} -> #{response}"
    rescue StandardError => e
      logger.error "Error computing flag remotely: #{e}. #{e.backtrace.join("\n")}"
    end
  end

  [response, flag_was_locally_evaluated]
end

#get_feature_variants(distinct_id, groups = {}, person_properties = {}, group_properties = {}) ⇒ Object 



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

def get_feature_variants(distinct_id, groups={}, person_properties={}, group_properties={})

  request_data = {
    "distinct_id": distinct_id,
    "groups": groups,
    "person_properties": person_properties,
    "group_properties": group_properties,
  }

  decide_data = _request_feature_flag_evaluation(request_data)

  if !decide_data.key?(:featureFlags)
    raise DecideAPIError.new(decide_data.to_json)
  else
    stringify_keys(decide_data[:featureFlags] || {})
  end
end

#load_feature_flags(force_reload = false) ⇒ Object 



45
46
47
48
49
 
# File 'lib/posthog/feature_flags.rb', line 45

def load_feature_flags(force_reload = false)
  if @loaded_flags_successfully_once.false? || force_reload
    _load_feature_flags
  end
end

#shutdown_poller ⇒ Object 



151
152
153
 
# File 'lib/posthog/feature_flags.rb', line 151

def shutdown_poller()
  @task.shutdown
end