flagger 2.0.9 → 3.0.1

data/lib/flagger/cloud.rb

@@ -1,495 +0,0 @@
-require 'eventmachine'
-require 'faraday'
-require 'faye/websocket'
-require 'json'
-require 'lru_redux'
-require 'set'
-require 'thread'
-require 'flagger/models'
-require 'flagger/stat'
-require 'flagger/version'
-
-module FlaggerEnvironments
-  SERVER_URL = 'https://api.airshiphq.com'
-  IDENTIFY_ENDPOINT = "#{SERVER_URL}/v2/identify"
-  GATING_INFO_ENDPOINT = "#{SERVER_URL}/v2/gating-info"
-
-  WEBSOCKET_URL = 'wss://ws.airshiphq.com'
-  WEBSOCKET_GATING_INFO_ENDPOINT = "#{WEBSOCKET_URL}/v2/ws-events"
-
-  CLOUDFRONT_URL = 'https://backup-api.airshiphq.com'
-  CLOUDFRONT_GATING_INFO_ENDPOINT = "#{CLOUDFRONT_URL}/v2/gating-info"
-
-  class CloudDelegate
-    attr_accessor :gating_info
-    attr_accessor :env_key
-    attr_accessor :request_timeout
-
-    def initialize(env_key, request_timeout)
-      @env_key = env_key
-      @request_timeout = request_timeout
-
-      @ingestion_max_items = 500
-      @ingestion_interval = 30
-      @ingestion_lock = Mutex.new
-
-      @entities = []
-      @stats = []
-      @exposures = []
-      @flags = Set[]
-      @ingested_flags = Set[]
-
-      @entity_lru_hashes = LruRedux::Cache.new(500)
-      @first_ingestion = true
-
-      @should_ingest_entities = true
-      @should_ingest_stats = true
-      @should_ingest_exposures = true
-      @should_ingest_flags = true
-
-      begin
-        get_gating_info("#{GATING_INFO_ENDPOINT}/#{@env_key}", 'duration__gating_info')
-      rescue Exception => e
-        STDERR.puts 'Failed to retrieve initial gating info from API', e.backtrace
-      end
-
-      begin
-        get_gating_info("#{CLOUDFRONT_GATING_INFO_ENDPOINT}/#{@env_key}", 'duration__cloudfront_gating_info') unless !@gating_info.nil?
-      rescue Exception => e
-        STDERR.puts 'Failed to retrieve initial gating info from CloudFront backup', e.backtrace
-      end
-
-      # ensure EventMachine is running
-      Thread.new { EventMachine.run } unless EventMachine.reactor_running?
-      Thread.pass until EventMachine.reactor_running?
-
-      em_subscribe_updates
-      em_police_updates
-      em_ingestion_timer
-    end
-
-    def get_gating_info(url, stat_name)
-      stat = FlaggerUtils::Stat.new(stat_name)
-      stat.start
-      conn = Faraday.new(url: url)
-      response = conn.get do |req|
-        req.options.timeout = @request_timeout
-      end
-      if response.status == 200
-        @gating_info = FlaggerModels::GatingInfo.new(JSON.parse(response.body))
-        update_sdk_vars(@gating_info)
-        stat.stop
-        save_stat(stat)
-      else
-        raise "Gating info request failed with HTTP code #{response.code}"
-      end
-    end
-
-    def em_subscribe_updates()
-      @ws_unsubbed = false
-      @ws = Faye::WebSocket::Client.new("#{WEBSOCKET_GATING_INFO_ENDPOINT}?envkey=#{@env_key}")
-
-      @ws.on :message do |event|
-        begin
-          @last_ws_update = Time.now
-          @gating_info = FlaggerModels::GatingInfo.new(JSON.parse(event.data))
-          update_sdk_vars(@gating_info)
-        rescue Exception => e
-          STDERR.puts 'Failed to update gating information', e
-        end
-      end
-
-      @ws.on :close do |event|
-        STDERR.puts ['Connection closed to Airship update server', event.code, event.reason] unless @ws_unsubbed
-        EventMachine::Timer.new(5) do
-          em_subscribe_updates unless @ws_unsubbed
-        end
-      end
-    end
-
-    def unsubscribe_updates()
-      @ws_unsubbed = true
-      @ws&.close
-    end
-
-    def em_police_updates
-      ping_timer = EventMachine::PeriodicTimer.new(5) do
-        if @cleaning then
-          ping_timer.cancel
-        else
-          @ws&.ping do
-            @last_ws_update = Time.now
-          end
-        end
-      end
-
-      police_update_timer = EventMachine::PeriodicTimer.new(30) do
-        if @cleaning then
-          police_update_timer.cancel
-        else
-          if Time.now - (@last_ws_update || Time.new(0)) > 30
-            STDERR.puts 'Did not receive a keepalive for more than 30 seconds. Reconnecting.'
-            @ws&.close
-          end
-        end
-      end
-
-      poll_gating_info_timer = EventMachine::PeriodicTimer.new(60) do
-        if @cleaning then
-          poll_gating_info_timer.cancel
-        else
-          if Time.now - (@last_ws_update || Time.new(0)) > 60
-            EM.defer(proc {
-                       STDERR.puts 'Did not receive a keepalive for more than 60 seconds. Polling gating info.'
-                       begin
-                         get_gating_info("#{CLOUDFRONT_GATING_INFO_ENDPOINT}/#{@env_key}", 'duration__cloudfront_gating_info')
-                         STDERR.puts 'Polled gating info from CloudFront'
-                       rescue Exception => e
-                         STDERR.puts 'Failed polling gating info from CloudFront', e.backtrace
-                       end
-                     })
-          end
-        end
-      end
-    end
-
-    def update_sdk_vars(gating_info)
-      if gating_info&.sdk_info&.ingestion_max_items then
-        @ingestion_max_items = gating_info.sdk_info.ingestion_max_items
-      end
-      if gating_info&.sdk_info&.ingestion_interval then
-        @ingestion_interval = gating_info.sdk_info.ingestion_interval
-      end
-      if gating_info&.sdk_info&.should_ingest_entities then
-        @should_ingest_entities = gating_info.sdk_info.should_ingest_entities
-      end
-      if gating_info&.sdk_info&.should_ingest_stats then
-        @should_ingest_stats = gating_info&.sdk_info&.should_ingest_stats
-      end
-      if gating_info&.sdk_info&.should_ingest_exposures then
-        @should_ingest_exposures = gating_info&.sdk_info&.should_ingest_exposures
-      end
-      if gating_info&.sdk_info&.should_ingest_flags then
-        @should_ingest_flags = gating_info&.sdk_info&.should_ingest_flags
-      end
-    end
-
-    def maybe_ingest(should_ingest = false)
-      if !@should_ingest_entities then
-        @entities = []
-      end
-
-      if !@should_ingest_stats then
-        @stats = []
-      end
-
-      if !@should_ingest_exposures then
-        @exposures = []
-      end
-
-      if !@should_ingest_flags then
-        @flags = Set[]
-      end
-
-      should_ingest |= (
-        @entities.length > @ingestion_max_items ||
-        @stats.length > @ingestion_max_items ||
-        @exposures.length > @ingestion_max_items ||
-        @flags.length > 0
-      )
-
-      if @first_ingestion then
-        should_ingest |= @entities.length > 0
-        @first_ingestion = !should_ingest
-      end
-
-      should_ingest &= (
-        @entities.length > 0 ||
-        @stats.length > 0 ||
-        @exposures.length > 0 ||
-        @flags.length > 0
-      )
-
-      if should_ingest then
-        entities = @entities
-        stats = @stats
-        exposures = @exposures
-        flags = @flags.to_a
-        @entities = []
-        @stats = []
-        @exposures = []
-        @ingested_flags.merge(@flags)
-        @flags = Set[]
-
-        EM.defer(
-          proc {
-            begin
-              conn = Faraday.new(url: "#{IDENTIFY_ENDPOINT}/#{@env_key}")
-              response = conn.post do |req|
-                req.options.timeout = @request_timeout
-                req.headers['Content-Type'] = 'application/json'
-                req.body = JSON.generate(
-                  {
-                    'sdk_info' => {
-                      'name' => 'ruby',
-                      'version' => FlaggerUtils::VERSION
-                    },
-                    'objects' => entities,
-                    'stats' => stats,
-                    'exposures' => exposures,
-                    'flags' => flags
-                  })
-              end
-              if response.status != 200 then
-                STDERR.puts 'Failed to upload entities', response.status
-                nil
-              end
-            rescue Exception => e
-              STDERR.puts 'Failed to upload entities', e
-              nil
-            end
-          })
-      end
-    end
-
-    def em_ingestion_timer
-      seconds = 0
-      timer = EventMachine::PeriodicTimer.new(1) do
-        timer.cancel unless !@cleaning
-
-        seconds = (seconds + 1) % @ingestion_interval
-        if seconds == 0 then
-          @ingestion_lock.synchronize {
-            maybe_ingest(true)
-          }
-        end
-      end
-    end
-
-    def cleanup()
-      @cleaning = true
-      unsubscribe_updates
-      @ingestion_lock.synchronize {
-        maybe_ingest(true)
-      }
-    end
-
-    def save_entity(entity)
-      @ingestion_lock.synchronize {
-        if @entity_lru_hashes[entity.id] != entity.hash then
-          @entity_lru_hashes[entity.id] = entity.hash
-          @entities.push(entity.attrs)
-          maybe_ingest()
-        end
-      }
-    end
-
-    def save_stat(stat)
-      @ingestion_lock.synchronize {
-        @stats.push(stat)
-        @stats = FlaggerUtils::Stat.compact(@stats)
-        maybe_ingest()
-      }
-    end
-
-    def save_exposure(exposure)
-      @ingestion_lock.synchronize {
-        @exposures.push(exposure)
-        maybe_ingest()
-      }
-    end
-
-    def save_flag(flag)
-      @ingestion_lock.synchronize {
-        @flags.add(flag)
-        maybe_ingest()
-      }
-    end
-
-    def stringify_keys(hash)
-      if hash.is_a?(Hash) then
-        hash.map {|k, v|
-          [k.to_s, stringify_keys(v)]
-        }.to_h
-      else
-        hash
-      end
-    end
-
-    def identify_entity(entity_json)
-      if !entity_json.is_a?(Hash) then
-        STDERR.puts 'Entity must be a hash'
-        nil
-      else
-        entity_json = stringify_keys(entity_json)
-
-        entity = if entity_json['is_group'] then
-                   FlaggerModels::GroupEntity.new(entity_json)
-                 else
-                   FlaggerModels::SingleEntity.new(entity_json)
-                 end
-
-        if !entity.valid? then
-          STDERR.puts "Entity validation errors: #{entity.validation_errors}"
-          nil
-        else
-          save_entity(entity)
-
-          entity
-        end
-      end
-    end
-
-    def treatment(flagger_flag, entity_json)
-      stat = FlaggerUtils::Stat.new('duration__get_treatment')
-      stat.start()
-
-      entity = identify_entity(entity_json)
-      flag = @gating_info&.flag(flagger_flag.flag_name)
-      if flag.nil? && !@ingested_flags.include?(flagger_flag.flag_name) then
-        save_flag(flagger_flag.flag_name)
-      end
-      return_value = flag&.treatment(entity)
-
-      if !return_value then
-        return return_value
-      end
-
-      exposure = {
-        flag: flagger_flag.flag_name,
-        type: entity.type,
-        id: entity.id,
-        treatment: return_value[:treatment].codename,
-        method_called: 'get_treatment',
-        eligible: return_value[:eligible]
-      }
-
-      return_value = return_value[:treatment].codename
-
-      save_exposure(exposure)
-
-      stat.stop()
-      save_stat(stat)
-
-      return_value
-    end
-
-
-    def payload(flagger_flag, entity_json)
-      stat = FlaggerUtils::Stat.new('duration__get_payload')
-      stat.start()
-
-      entity = identify_entity(entity_json)
-      flag = @gating_info&.flag(flagger_flag.flag_name)
-      if flag.nil? && !@ingested_flags.include?(flagger_flag.flag_name) then
-        save_flag(flagger_flag.flag_name)
-      end
-      return_value = flag&.payload(entity)
-
-      if !return_value then
-        return return_value
-      end
-
-      exposure = {
-        flag: flagger_flag.flag_name,
-        type: entity.type,
-        id: entity.id,
-        treatment: return_value[:treatment].codename,
-        method_called: 'get_payload',
-        eligible: return_value[:eligible]
-      }
-
-      return_value = return_value[:treatment].payload
-
-      save_exposure(exposure)
-
-      stat.stop()
-      save_stat(stat)
-
-      return_value
-    end
-
-    def eligible?(flagger_flag, entity_json)
-      stat = FlaggerUtils::Stat.new('duration__is_eligible')
-      stat.start()
-
-      entity = identify_entity(entity_json)
-      flag = @gating_info&.flag(flagger_flag.flag_name)
-      if flag.nil? && !@ingested_flags.include?(flagger_flag.flag_name) then
-        save_flag(flagger_flag.flag_name)
-      end
-      return_value = flag&.eligible?(entity)
-
-      if !return_value then
-        return return_value
-      end
-
-      exposure = {
-        flag: flagger_flag.flag_name,
-        type: entity.type,
-        id: entity.id,
-        treatment: return_value[:treatment].codename,
-        method_called: 'is_eligible',
-        eligible: return_value[:eligible]
-      }
-
-      return_value = return_value[:eligible]
-
-      save_exposure(exposure)
-
-      stat.stop()
-      save_stat(stat)
-
-      return_value
-    end
-
-    def enabled?(flagger_flag, entity_json)
-      stat = FlaggerUtils::Stat.new('duration__is_enabled')
-      stat.start()
-
-      entity = identify_entity(entity_json)
-      flag = @gating_info&.flag(flagger_flag.flag_name)
-      if flag.nil? && !@ingested_flags.include?(flagger_flag.flag_name) then
-        save_flag(flagger_flag.flag_name)
-      end
-      return_value = flag&.enabled?(entity)
-
-      if !return_value then
-        return return_value
-      end
-
-      exposure = {
-        flag: flagger_flag.flag_name,
-        type: entity.type,
-        id: entity.id,
-        treatment: return_value[:treatment].codename,
-        method_called: 'is_enabled',
-        eligible: return_value[:eligible]
-      }
-
-      return_value = !return_value[:treatment].is_off_treatment
-
-      save_exposure(exposure)
-
-      stat.stop()
-      save_stat(stat)
-
-      return_value
-    end
-
-    def publish(entities)
-      if !entities.is_a?(Array) then
-        STDERR.puts 'The "publish" method takes an array of objects (aka entities).'
-        return nil
-      end
-
-      entities.each do |entity|
-        identify_entity(entity)
-      end
-
-      @ingestion_lock.synchronize {
-        maybe_ingest(true)
-      }
-    end
-  end
-end