flagger 2.0.5 → 3.0.1

data/lib/flagger/cloud.rb

@@ -1,440 +0,0 @@
-require 'eventmachine'
-require 'faraday'
-require 'faye/websocket'
-require 'json'
-require 'lru_redux'
-require 'set'
-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
-
-      @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
-
-      if EM.reactor_running? then
-        em_subscribe_updates
-        em_ingestion_timer
-      else
-        Thread.new {
-          EM.run {
-            em_subscribe_updates
-            em_ingestion_timer
-          }
-        }
-      end
-    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
-          @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
-        end unless @ws_unsubbed
-      end
-    end
-
-    def unsubscribe_updates()
-      @ws_unsubbed = true
-      @ws.close()
-    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
-        begin
-          entities = @entities
-          stats = @stats
-          exposures = @exposures
-          flags = @flags.to_a
-          @entities = []
-          @stats = []
-          @exposures = []
-          @ingested_flags.merge(@flags)
-          @flags = Set[]
-
-          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
-          EM.defer(proc {
-            maybe_ingest(true)
-          })
-        end
-      end
-    end
-
-    def cleanup()
-      @cleaning = true
-      unsubscribe_updates
-      maybe_ingest(true)
-    end
-
-    def save_entity(entity)
-      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)
-      @stats.push(stat)
-      @stats = FlaggerUtils::Stat.compact(@stats)
-      maybe_ingest()
-    end
-
-    def save_exposure(exposure)
-      @exposures.push(exposure)
-      maybe_ingest()
-    end
-
-    def save_flag(flag)
-      @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
-
-      maybe_ingest(true)
-    end
-  end
-end

data/lib/flagger/microservice.rb

@@ -1,63 +0,0 @@
-require 'faraday'
-require 'json'
-
-module FlaggerEnvironments
-  class MicroserviceDelegate
-    attr_accessor :env_key
-    attr_accessor :edge_url
-    attr_accessor :request_timeout
-
-    def initialize(env_key, edge_url, request_timeout)
-      @env_key = env_key
-      @edge_url = edge_url
-      @request_timeout = request_timeout
-    end
-
-    def treatment(flag, entity)
-      get_object_values(flag, entity)['treatment'] rescue nil
-    end
-
-    def payload(flag, entity)
-      get_object_values(flag, entity)['payload'] rescue nil
-    end
-
-    def eligible?(flag, entity)
-      get_object_values(flag, entity)['isEligible'] rescue nil
-    end
-
-    def enabled?(flag, entity)
-      get_object_values(flag, entity)['isEnabled'] rescue nil
-    end
-
-    def publish(entities)
-    end
-
-    def cleanup()
-    end
-
-    private
-    def get_object_values(flag, entity)
-      begin
-        conn = Faraday.new(url: "#{@edge_url}/v2/object-values/#{@env_key}")
-        response = conn.post do |req|
-          req.options.timeout = @request_timeout
-          req.headers['Content-Type'] = 'application/json'
-          req.body = JSON.generate({
-                                     'flag' => flag.flag_name,
-                                     'entity' => entity,
-                                   })
-        end
-        if response.status == 200
-          object_values = JSON.parse(response.body)
-          object_values
-        else
-          puts 'Failed to connect to Airship edge server'
-          nil
-        end
-      rescue Exception => e
-        puts 'Failed to connect to Airship edge server', e
-        nil
-      end
-    end
-  end
-end