flagger 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fd2012064f6365502851698b36a4aca47eb948730956ae20b3ab6fd7431456e0
+  data.tar.gz: a7d18728dc84c3d3f17cab164ce8893fe9857b6e832a27ca0b7cee947eed495a
+SHA512:
+  metadata.gz: d63e4863cf230e9aabc956e06a8b0a88228bda6234230c2ce4766f2a4e71efc5b7d429608693791c8fdb62bcc050a625b311669b90c952ef818590bcb21e68ed
+  data.tar.gz: 2b93f074f5318ab8feffb2ed9bcd9726756c42d6a4d5a059364217407f531a1a84152ad13ba28ce085b220a984bd57a40c53a199db95f2f17144eb623dbacc6a

data/lib/flagger/cloud.rb

@@ -0,0 +1,287 @@
+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)
+      @entity_lru_hashes = LruRedux::Cache.new(500)
+      @entities = []
+      @stats = []
+      @exposures = []
+      @flags = Set[]
+      @ingested_flags = Set[]
+      @env_key = env_key
+      @request_timeout = request_timeout
+
+      @ingestion_max_items = 500
+      @ingestion_interval = 30
+
+      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
+    end
+
+    def maybe_ingest(should_ingest = false)
+      should_ingest |= (
+        @entities.length > @ingestion_max_items ||
+        @stats.length > @ingestion_max_items ||
+        @exposures.length > @ingestion_max_items ||
+        @flags.length > 0
+      )
+
+      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 identify_entity(entity_json)
+      if !entity_json.is_a?(Hash) then
+        STDERR.puts 'Entity must be a hash'
+        nil
+      else
+        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
+
+    {
+      'treatment' => 'duration__get_treatment',
+      'payload' => 'duration__get_payload',
+      'eligible?' => 'duration__is_eligible',
+      'enabled?' => 'duration__is_enabled',
+    }.each do |name, stat_name|
+      define_method(name.to_sym) do |flagger_flag, entity_json|
+        stat = FlaggerUtils::Stat.new(stat_name)
+        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&.public_send(name, entity)
+
+        if name == 'treatment' and !return_value.nil? then
+          exposure = {
+            type: entity.type,
+            id: entity.id,
+            treatment_id: return_value.treatment_id,
+            treatment: return_value.codename
+          }
+
+          return_value = return_value.codename
+
+          save_exposure(exposure)
+        end
+
+        stat.stop()
+        save_stat(stat)
+
+        return_value
+      end
+    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

@@ -0,0 +1,63 @@
+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

data/lib/flagger/models.rb

@@ -0,0 +1,643 @@
+require 'digest'
+require 'dry-validation'
+
+module FlaggerModels
+  class BaseEntity
+    SCHEMA = Dry::Validation.Schema do
+      configure do
+        def valid_attribute_names?(attributes)
+          attributes.keys.all? do |name|
+            name.is_a?(String) && /^[a-zA-Z]$|^[a-zA-Z_]{0,48}[a-zA-Z]$/ =~ name
+          end
+        end
+
+        def valid_attribute_values?(attributes)
+          attributes.values.all? do |v|
+            (v.is_a?(String) && v.length <= 3000) || [true, false].include?(v) || v.is_a?(Numeric)
+          end
+        end
+
+        def self.messages
+          super.merge(
+            en: {
+              errors: {
+                :valid_attribute_names? => 'Each attribute must begin and end with an alphabet letter (a-z, A-Z). In between, allowed characters are a-z, A-Z, and "_". For example: isStudent or is_student. Preceding or trailing underscore is not allowed (i.e., _is_student or is_student_).',
+                :valid_attribute_values? => "An entity's attribute value must be a string no more than 3000 characters, boolean, or number."
+              }
+            }
+          )
+        end
+      end
+
+      optional('type') { str? & size?(1..50) & format?(/^([A-Z][a-zA-Z]*)+$/) }
+      required('id') { str? & size?(1..250) }
+      optional('display_name') { str? & size?(1..250) }
+      optional('attributes') { type?(Hash) & size?(0..100) & valid_attribute_names? & valid_attribute_values? }
+      required('is_group') { bool? }
+    end
+
+    attr_accessor :type
+    attr_accessor :id
+    attr_accessor :display_name
+    attr_accessor :attributes
+    attr_accessor :is_group
+
+    def initialize(json)
+      @type = json['type']
+      @id = json['id']
+      if @id.is_a?(Numeric) then
+        @id = @id.to_s
+      end
+      @display_name = json['display_name'] || @id if @id.is_a?(String)
+      @attributes = json['attributes'] || {}
+    end
+
+    def attrs()
+      instance_variables.map do |var|
+        if var == :@group then
+          group = instance_variable_get(var)
+          [var[1..-1], if defined? group.attrs then group.attrs else group end]
+        else
+          [var[1..-1], instance_variable_get(var)]
+        end
+      end.to_h.delete_if { |k,v| v.nil? }
+    end
+
+    def hash()
+      attrs.hash
+    end
+
+    def validation_errors()
+      SCHEMA.(attrs).errors
+    end
+
+    def valid?()
+      validation_errors.length === 0
+    end
+  end
+
+  class GroupEntity < BaseEntity
+    def initialize(json)
+      super(json)
+      @is_group = true
+    end
+  end
+
+  class SingleEntity < BaseEntity
+    SCHEMA = Dry::Validation.Schema do
+      optional('group').schema(GroupEntity::SCHEMA)
+    end
+
+    attr_accessor :group
+
+    def initialize(json)
+      super(json)
+      @group = json['group']&.is_a?(Hash) && GroupEntity.new(json['group'])
+      @is_group = false
+
+      if @type == nil then
+        @type = 'User'
+      end
+
+      if @group && @group.type.nil? then
+        @group.type = @type + 'Group'
+      end
+    end
+
+    def validation_errors()
+      if @group != nil then
+        group_errors = SingleEntity::SCHEMA.(attrs).errors
+        super.merge(group_errors)
+      else
+        super
+      end
+    end
+  end
+
+  class GatingInfoModel
+    def validate()
+      messages = self.class::SCHEMA.(attrs).messages
+      raise RuntimeError.new(messages) if messages.length > 0
+    end
+
+    def attrs()
+      instance_variables.map do |var|
+        value = instance_variable_get(var)
+        if value != nil then
+          [var, value]
+        else
+          nil
+        end
+      end.compact.to_h
+    end
+  end
+
+  class GatingInfo
+    attr_reader :sdk_info
+    attr_reader :flags
+    attr_reader :env
+
+    def initialize(json)
+      @sdk_info = SdkInfo.new(json['sdk_info'] || {})
+      @env = Env.new(json['env'])
+      @flags = Hash[json['flags'].map {|flag| [flag['codename'], Flag.new(flag, @env.hash_key)]}]
+    end
+
+    def flag(name)
+      @flags[name]
+    end
+  end
+
+  class SdkInfo < GatingInfoModel
+    SCHEMA = Dry::Validation.Schema do
+      optional(:@ingestion_interval) { int? }
+      optional(:@ingestion_max_items) { int? }
+    end
+
+    attr_reader :ingestion_interval
+    attr_reader :ingestion_max_items
+
+    def initialize(json)
+      @ingestion_interval = json['SDK_INGESTION_INTERVAL']
+      @ingestion_max_items = json['SDK_INGESTION_MAX_ITEMS']
+
+      validate
+    end
+  end
+
+  class Env < GatingInfoModel
+    SCHEMA = Dry::Validation.Schema do
+      required(:@env_key) { str? }
+      required(:@hash_key) { str? }
+    end
+
+    attr_reader :env_key
+    attr_reader :hash_key
+
+    def initialize(json)
+      @env_key = json['env_key']
+      @hash_key = json['hash_key']
+
+      validate
+    end
+  end
+
+  class Flag < GatingInfoModel
+    SCHEMA = Dry::Validation.Schema do
+      required(:@codename) { str? }
+      required(:@flag_status) { included_in? ['operational', 'archived'] }
+      required(:@flag_type) { included_in? ['basic', 'experiment', 'uncategorized'] }
+      required(:@hash_key) { str? }
+      optional(:@is_paused) { bool? }
+      required(:@is_web_accessible) { bool? }
+      required(:@overrides) { hash? }
+      required(:@populations) { array? }
+      required(:@splits) { hash? }
+      required(:@treatments) { hash? }
+
+      required(:@env_hash_key) { str? }
+    end
+
+    attr_reader :codename
+    attr_reader :flag_status
+    attr_reader :flag_type
+    attr_reader :hash_key
+    attr_reader :is_paused
+    attr_reader :is_web_accessible
+    attr_reader :overrides
+    attr_reader :populations
+    attr_reader :splits
+    attr_reader :treatments
+
+    attr_reader :env_hash_key
+
+    def initialize(json, env_hash_key)
+      @codename = json['codename']
+      @flag_status = json['flag_status']
+      @flag_type = json['flag_type']
+      @hash_key = json['hash_key']
+      @is_paused = json['is_paused']
+      @is_web_accessible = json['is_web_accessible']
+      @overrides = Hash[(json['overrides'] || []).map {|override| ["#{override['entity_type']}_#{override['entity_id']}", Override.new(override)]}]
+      @populations = (json['populations'] || []).map {|population| Population.new(population)}
+      @splits = Hash[(json['splits'] || []).map {|split| [split['treatment_id'], Split.new(split)]}]
+      @treatments = Hash[(json['treatments'] || []).map {|treatment| [treatment['treatment_id'], Treatment.new(treatment)]}]
+
+      @env_hash_key = env_hash_key
+
+      validate
+    end
+
+    def treatment(entity)
+      if @flag_type == 'uncategorized' or !entity then
+        nil
+      else
+        resolved_allocation(@env_hash_key, entity)[:treatment]
+      end
+    end
+
+    def payload(entity)
+      if @flag_type == 'uncategorized' or !entity then
+        nil
+      else
+        resolved_allocation(@env_hash_key, entity)[:treatment].payload
+      end
+    end
+
+    def eligible?(entity)
+      if @flag_type == 'uncategorized' or !entity then
+        false
+      else
+        resolved_allocation(@env_hash_key, entity)[:eligible]
+      end
+    end
+
+    def enabled?(entity)
+      if @flag_type == 'uncategorized' or !entity then
+        false
+      else
+        not resolved_allocation(@env_hash_key, entity)[:treatment].is_off_treatment
+      end
+    end
+
+    def resolved_allocation(env_hash_key, entity)
+      resolve_allocations(
+        allocation(@env_hash_key, entity),
+        allocation(@env_hash_key, (entity.group if defined? entity.group))
+      )
+    end
+
+    def allocation(env_hash_key, entity)
+      off_allocation = {
+        treatment: @treatments.find {|treatment_id, treatment| treatment.is_off_treatment}[1],
+        eligible: false
+      }
+
+      if !entity.is_a?(BaseEntity) then
+        return off_allocation
+      end
+
+      if @flag_status == 'archived' then
+        STDERR.puts 'The flag has been archived'
+        return off_allocation
+      end
+
+      if @is_paused then
+        return off_allocation
+      end
+
+      treatment = @treatments[@overrides["#{entity.type}_#{entity.id}"]&.treatment_id]
+      if treatment then
+        return {
+          treatment: treatment,
+          eligible: !treatment.is_off_treatment,
+          from_override: true
+        }
+      end
+
+      use_universes = @flag_type == 'experiment'
+
+      is_eligible = false
+      @populations.each do |population|
+        eligible, treatment = population.gate_values(
+                    entity,
+                    env_hash_key,
+                    self,
+                    use_universes
+                  ).values_at(:eligible, :treatment)
+
+        if treatment != nil then
+          return {
+            treatment: treatment,
+            eligible: eligible
+          }
+        end
+
+        is_eligible ||= eligible
+      end
+
+      {
+        treatment: off_allocation[:treatment],
+        eligible: is_eligible
+      }
+    end
+
+    def resolve_allocations(individual_alloc, group_alloc)
+      if individual_alloc[:from_override] then
+        individual_alloc
+      elsif group_alloc[:from_override] then
+        group_alloc
+      elsif not individual_alloc[:treatment].is_off_treatment then
+        individual_alloc
+      elsif not group_alloc[:treatment].is_off_treatment then
+        group_alloc
+      else
+        individual_alloc
+      end
+    end
+  end
+
+  class Override < GatingInfoModel
+    SCHEMA = Dry::Validation.Schema do
+      required(:@treatment_id) { str? }
+      required(:@entity_id) { str? }
+      required(:@entity_type) { str? }
+    end
+
+    attr_reader :treatment_id
+    attr_reader :entity_id
+    attr_reader :entity_type
+
+    def initialize(json)
+      @treatment_id = json['treatment_id']
+      @entity_id = json['entity_id']
+      @entity_type = json['entity_type']
+
+      validate
+    end
+  end
+
+  class Population < GatingInfoModel
+    SCHEMA = Dry::Validation.Schema do
+      required(:@rules) { array? }
+      required(:@universes) { array? }
+      required(:@percentage) { gteq?(0) & lteq?(1) }
+      required(:@hash_key) { str? }
+      required(:@entity_type) { str? }
+    end
+
+    attr_reader :rules
+    attr_reader :universes
+    attr_reader :percentage
+    attr_reader :hash_key
+    attr_reader :entity_type
+
+    def initialize(json)
+      @rules = (json['rules'] || []).map {|rule| Rule.new(rule)}
+      @universes = (json['universes'] || []).map {|universe| Hash[universe.map {|split| [split['treatment_id'], Split.new(split)]}]}
+      @percentage = json['percentage']
+      @hash_key = json['hash_key']
+      @entity_type = json['entity_type']
+
+      validate
+    end
+
+    def gate_values(entity, env_hash_key, flag, sticky)
+      if @entity_type != entity.type
+        return {eligible: false}
+      end
+
+      matches = @rules.all? {|rule| rule.match(entity)}
+      if matches then
+        samplingHashKey = "SAMPLING:control_#{flag.hash_key}:env_#{env_hash_key}:rule_set_#{@hash_key}:client_object_#{entity.type}_#{entity.id}"
+        if Population.getHashedPercentage(samplingHashKey) <= @percentage and @percentage > 0 then
+
+          allocationHashKey = "DISTRIBUTION:control_#{flag.hash_key}:env_#{env_hash_key}:client_object_#{entity.type}_#{entity.id}"
+          allocationHashedPercentage = Population.getHashedPercentage(allocationHashKey)
+
+          splits = if sticky then
+                     @universes[(@percentage * 100).floor - 1]
+                   else
+                     flag.splits
+                   end
+
+          sum = 0
+          {
+            eligible: true,
+            treatment: flag.treatments.find {|treatment_id, treatment|
+              if treatment.is_off_treatment then
+                false
+              else
+                sum = (sum + (splits[treatment.treatment_id]&.percentage || 0)).round(3)
+                allocationHashedPercentage <= sum
+              end
+            }[1]
+          }
+        else
+          {eligible: true}
+        end
+      else
+        {eligible: false}
+      end
+    end
+
+    def self.getHashedPercentage(s)
+      Digest::MD5.hexdigest(s).to_i(16).to_f / 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
+    end
+  end
+
+  module RuleType
+    STRING = 'string'
+    INT = 'int'
+    FLOAT = 'float'
+    BOOLEAN = 'boolean'
+    DATE = 'date'
+    DATETIME = 'datetime'
+  end
+
+  module RuleOperator
+    IS = 'is'
+    IS_NOT = 'is_not'
+    IN = 'in'
+    NOT_IN = 'not_in'
+    LT = 'lt'
+    LTE = 'lte'
+    GT = 'gt'
+    GTE = 'gte'
+    FROM = 'from'
+    UNTIL = 'until'
+    AFTER = 'after'
+    BEFORE = 'before'
+  end
+
+  class Rule < GatingInfoModel
+    SCHEMA = Dry::Validation.Schema do
+      required(:@operator) { included_in? RuleOperator.constants(false).map(&RuleOperator.method(:const_get)) }
+      required(:@attribute_type) { included_in? RuleType.constants(false).map(&RuleType.method(:const_get)) }
+      required(:@attribute_name) { str? }
+      optional(:@value_list) { array? { each { str? | bool? | type?(Numeric) } } }
+      optional(:@value) { str? | bool? | type?(Numeric) }
+    end
+
+    attr_reader :operator
+    attr_reader :attribute_type
+    attr_reader :attribute_name
+    attr_reader :value_list
+    attr_reader :value
+
+    def initialize(json)
+      @operator = json['operator']
+      @attribute_type = json['attribute_type']
+      @attribute_name = json['attribute_name']
+      @value_list = json['value_list']
+      @value = json['value']
+
+      validate
+    end
+
+    def self.categorize_value_type(value)
+      case value
+      when true
+        'boolean'
+      when false
+        'boolean'
+      when Float
+        'float'
+      when Integer
+        'int'
+      when String
+        begin
+          date = DateTime.parse(value)
+          if date.hour == 0 && date.minute == 0 && date.second == 0 && date.second_fraction == 0 then
+            'date'
+          else
+            'datetime'
+          end
+        rescue ArgumentError
+          'string'
+        end
+      else
+        STDERR.puts 'Unexpected attribute value type encountered'
+        nil
+      end
+    end
+
+    def match(entity)
+      begin
+        if not entity.attributes.key?(@attribute_name) then
+          return false
+        end
+
+        value = entity.attributes[@attribute_name]
+        attribute_type = Rule.categorize_value_type(value)
+        number_types = [RuleType::INT, RuleType::FLOAT].sort
+
+        if attribute_type != @attribute_type &&
+           [attribute_type, @attribute_type].sort != number_types then
+          return false
+        end
+
+        if attribute_type == RuleType::STRING then
+          if @operator == RuleOperator::IS then
+            value == @value
+          elsif @operator == RuleOperator::IS_NOT then
+            value != @value
+          elsif @operator == RuleOperator::IN then
+            @value_list.include?(value)
+          elsif @operator == RuleOperator::NOT_IN then
+            not @value_list.include?(value)
+          else
+            STDERR.puts 'Invalid rule operator encountered'
+            false
+          end
+        elsif number_types.include?(attribute_type) then
+          if @operator == RuleOperator::IS then
+            value == @value
+          elsif @operator == RuleOperator::IS_NOT then
+            value != @value
+          elsif @operator == RuleOperator::IN then
+            @value_list.include?(value)
+          elsif @operator == RuleOperator::NOT_IN then
+            not @value_list.include?(value)
+          elsif @operator == RuleOperator::LT then
+            value < @value
+          elsif @operator == RuleOperator::LTE then
+            value <= @value
+          elsif @operator == RuleOperator::GT then
+            value > @value
+          elsif @operator == RuleOperator::GTE then
+            value >= @value
+          else
+            STDERR.puts 'Invalid rule operator encountered'
+            false
+          end
+        elsif attribute_type == RuleType::BOOLEAN then
+          if @operator == RuleOperator::IS then
+            value == @value
+          elsif @operator == RuleOperator::IS_NOT then
+            value != @value
+          else
+            STDERR.puts 'Invalid rule operator encountered'
+            false
+          end
+        elsif attribute_type == RuleType::DATE || attribute_type == RuleType::DATETIME then
+          target_time = @value && DateTime.parse(@value)
+          target_time_list = @value_list&.map {|tv| DateTime.parse(tv)}
+          value_time = DateTime.parse(value)
+
+          if @operator == RuleOperator::IS then
+            value_time == target_time
+          elsif @operator == RuleOperator::IS_NOT then
+            value_time != target_time
+          elsif @operator == RuleOperator::IN then
+            target_time_list.include?(value_time)
+          elsif @operator == RuleOperator::NOT_IN then
+            not target_time_list.include?(value_time)
+          elsif @operator == RuleOperator::FROM then
+            value_time >= target_time
+          elsif @operator == RuleOperator::UNTIL then
+            value_time <= target_time
+          elsif @operator == RuleOperator::AFTER then
+            value_time > target_time
+          elsif @operator == RuleOperator::BEFORE then
+            value_time < target_time
+          else
+            STDERR.puts 'Invalid rule operator encountered'
+            false
+          end
+        else
+          STDERR.puts 'Invalid attribute type encountered'
+          false
+        end
+      rescue Exception => e
+        STDERR.puts "Traceback:"
+        STDERR.puts e.backtrace
+        STDERR.puts "#{e.class} (#{e.message})"
+        false
+      end
+    end
+  end
+
+  class Split < GatingInfoModel
+    SCHEMA = Dry::Validation.Schema do
+      required(:@treatment_id) { str? }
+      required(:@percentage) { gteq?(0) & lteq?(1) }
+    end
+
+    attr_reader :treatment_id
+    attr_reader :percentage
+
+    def initialize(json)
+      @treatment_id = json['treatment_id']
+      @percentage = json['percentage']
+
+      validate
+    end
+  end
+
+  class Treatment < GatingInfoModel
+    SCHEMA = Dry::Validation.Schema do
+      required(:@treatment_id) { str? }
+      required(:@is_control) { bool? }
+      required(:@codename) { str? }
+      required(:@is_off_treatment) { bool? }
+      optional(:@payload) { str? }
+    end
+
+    attr_reader :treatment_id
+    attr_reader :is_control
+    attr_reader :codename
+    attr_reader :is_off_treatment
+    attr_reader :payload
+
+    def initialize(json)
+      @treatment_id = json['treatment_id']
+      @is_control = json['is_control']
+      @codename = json['codename']
+      @is_off_treatment = json['is_off_treatment']
+      @payload = json['payload']
+
+      validate
+    end
+  end
+end

data/lib/flagger/stat.rb

@@ -0,0 +1,56 @@
+require 'json'
+
+module FlaggerUtils
+  class Stat
+    attr_reader :name
+    attr_accessor :duration
+    attr_accessor :count
+
+    def self.compact(stats)
+      groups = stats.group_by {|stat| stat.name}
+      groups.values.map do |same_stats|
+        new_stat = Stat.new(same_stats[0].name)
+        new_stat.count = same_stats.reduce(0) {|count, stat| count + stat.count}
+        if same_stats[0].duration then
+          new_stat.duration = same_stats.reduce(0) {|duration, stat| duration + stat.duration * stat.count} / new_stat.count
+        end
+        new_stat
+      end
+    end
+
+    def initialize(name)
+      @name = name
+      @count = 0
+    end
+
+    def start()
+      @start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def stop()
+      @end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @duration = (@end_time - @start_time) * 1e9
+      @count = 1
+    end
+
+    def to_json(options={})
+      to_h.to_json(options)
+    end
+
+    def to_h()
+      if @duration then
+        {
+          name: name,
+          duration: @duration,
+          unit: 'ns',
+          count: @count
+        }
+      else
+        {
+          name: name,
+          count: @count
+        }
+      end
+    end
+  end
+end

data/lib/flagger.rb

@@ -0,0 +1,87 @@
+require 'flagger/cloud'
+require 'flagger/microservice'
+
+class Flagger
+  class Flag
+    attr_accessor :flag_name
+    attr_accessor :delegate
+
+    def initialize(flag_name, delegate)
+      @flag_name = flag_name
+      @delegate = delegate
+    end
+
+    def treatment(entity)
+      @delegate&.treatment(self, entity) || 'off'
+    end
+
+    def payload(entity)
+      @delegate&.payload(self, entity) || nil
+    end
+
+    def eligible?(entity)
+      @delegate&.eligible?(self, entity) || false
+    end
+
+    def enabled?(entity)
+      @delegate&.enabled?(self, entity) || false
+    end
+  end
+
+  @@instance = Flagger.new
+
+  attr_accessor :env_key
+  attr_accessor :edge_url
+  attr_accessor :request_timeout
+  attr_accessor :delegate
+
+  def self.configure(options)
+    @@instance.configure(options)
+    @@instance
+  end
+
+  def configure(options)
+    @env_key = options[:env_key]
+    @edge_url = options[:edge_url]
+    @request_timeout = options[:request_timeout] || 10
+
+    @delegate&.cleanup
+    if @edge_url.nil? then
+      @delegate = FlaggerEnvironments::CloudDelegate.new(@env_key, @request_timeout)
+    else
+      @delegate = FlaggerEnvironments::MicroserviceDelegate.new(@env_key, @edge_url, @request_timeout)
+    end
+  end
+
+  def self.flag(flag_name)
+    Flag.new(flag_name, @@instance.delegate)
+  end
+
+  def self.publish(entities)
+    @@instance.delegate&.publish(entities)
+  end
+end
+
+class Airship
+  def initialize(options)
+    STDERR.puts 'The Airship class is deprecated.'
+
+    @env_key = options[:env_key]
+  end
+
+  def init()
+    Flagger.configure(env_key: @env_key)
+  end
+
+  def variation(flag, entity)
+    Flagger.flag(flag).treatment(entity)
+  end
+
+  def eligible?(flag, entity)
+    Flagger.flag(flag).eligible?(entity)
+  end
+
+  def enabled?(flag, entity)
+    Flagger.flag(flag).enabled?(entity)
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: flagger
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Airship Dev Team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-10-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.7
+- !ruby/object:Gem::Dependency
+  name: lru_redux
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+description: Ruby SDK
+email: support@airshiphq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/flagger.rb
+- lib/flagger/cloud.rb
+- lib/flagger/microservice.rb
+- lib/flagger/models.rb
+- lib/flagger/stat.rb
+homepage: https://airshiphq.com
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/airshiphq/flagger-ruby
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Flagger Ruby SDK
+test_files: []