amplitude-experiment 1.1.5 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4c7cef3c90843aec26f85cc3706300eb1f6bff3f64c1db9b4162bdf20dc1119
-  data.tar.gz: bd937b2d414b7b52b3accf57de14ac556a1789f83dd1e5d1625727ae5c9a0222
+  metadata.gz: f4b95fab3639837e3bb1223ad3ba71405d9f92384fa73dedca9daa83b8069dac
+  data.tar.gz: 3fdb770c922f5e82260cac4f53c1134555b85a3fb5ad91f5fd20956d3a42d300
 SHA512:
-  metadata.gz: c927c9bc9808738b641cdf6666e7fa3220dad2d68b275d2d9b4269ebedf5ade2cd421a4e7c77a4283d8c0c0cfd9be2579d209ac9e4430b989dcf6dd864b98b4b
-  data.tar.gz: b388bc2f602af8031e5fb01cdd862ea31149a142d0fcf559703cdb2a76554cc051a339be8e8670862a129669a09535342ed3a766411c931c9a1c1ec019dbd082
+  metadata.gz: 5e3ba791304dc10b7d27d34806d3a6b85b195a86035a0f5656410b0e541280fbf82053b06b8f1a13dd2bd8966d2cfa390b723733d73ce138cc8c4542d5431d29
+  data.tar.gz: 5eb707da5065fd9c8399d42967aa02c2f1705e944033e346579a01c4e66fe591c77cbfd812a0f6d1267be25995993a150014334727f80005f0114439a1562c30

data/amplitude-experiment.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths         = ['lib']
   spec.extra_rdoc_files      = ['README.md']
 
+  spec.add_development_dependency 'concurrent-ruby', '~> 1.2.2'
   spec.add_development_dependency 'psych', '~> 4.0'
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rdoc', '= 6.4'

data/lib/amplitude/client.rb

@@ -0,0 +1,54 @@
+module AmplitudeAnalytics
+  # Amplitude
+  class Amplitude
+    attr_reader :configuration
+
+    def initialize(api_key, configuration: nil)
+      @configuration = configuration || Config.new
+      @configuration.api_key = api_key
+      @timeline = Timeline.new
+      @timeline.setup(self)
+      add(AmplitudeDestinationPlugin.new)
+      add(ContextPlugin.new)
+      register_on_exit
+    end
+
+    def track(event)
+      @timeline.process(event)
+    end
+
+    def flush
+      @timeline.flush
+    end
+
+    def add(plugin)
+      @timeline.add(plugin)
+      plugin.setup(self)
+      self
+    end
+
+    def remove(plugin)
+      @timeline.remove(plugin)
+      self
+    end
+
+    def shutdown
+      @configuration.opt_out = true
+      @timeline.shutdown
+    end
+
+    private
+
+    def register_on_exit
+      if Thread.respond_to?(:_at_exit)
+        begin
+          at_exit { shutdown }
+        rescue StandardError
+          @configuration.logger.warning('register for exit fail')
+        end
+      else
+        at_exit { shutdown }
+      end
+    end
+  end
+end

data/lib/amplitude/config.rb

@@ -0,0 +1,78 @@
+require 'logger'
+module AmplitudeAnalytics
+  # Config
+  class Config
+    attr_accessor :api_key, :flush_interval_millis, :flush_max_retries,
+                  :logger, :min_id_length, :callback, :server_zone, :use_batch,
+                  :storage_provider, :opt_out, :ingestion_metadata
+
+    def initialize(api_key: nil, flush_queue_size: FLUSH_QUEUE_SIZE,
+                   flush_interval_millis: FLUSH_INTERVAL_MILLIS,
+                   flush_max_retries: FLUSH_MAX_RETRIES,
+                   logger: Logger.new($stdout, progname: LOGGER_NAME, level: Logger::ERROR),
+                   min_id_length: nil, callback: nil, server_zone: DEFAULT_ZONE,
+                   use_batch: false, server_url: nil,
+                   storage_provider: InMemoryStorageProvider.new, ingestion_metadata: nil)
+      @api_key = api_key
+      @flush_queue_size = flush_queue_size
+      @flush_size_divider = 1
+      @flush_interval_millis = flush_interval_millis
+      @flush_max_retries = flush_max_retries
+      @logger = logger
+      @min_id_length = min_id_length
+      @callback = callback
+      @server_zone = server_zone
+      @use_batch = use_batch
+      @server_url = server_url
+      @storage_provider = storage_provider
+      @opt_out = false
+      @ingestion_metadata = ingestion_metadata
+    end
+
+    def storage
+      @storage_provider.storage
+    end
+
+    def valid?
+      @api_key && @flush_queue_size > 0 && @flush_interval_millis > 0 && min_id_length_valid?
+    end
+
+    def min_id_length_valid?
+      @min_id_length.nil? || (@min_id_length.is_a?(Integer) && @min_id_length > 0)
+    end
+
+    def flush_queue_size
+      [@flush_queue_size / @flush_size_divider, 1].max
+    end
+
+    def flush_queue_size=(size)
+      @flush_queue_size = size
+      @flush_size_divider = 1
+    end
+
+    def server_url
+      @url || (
+        if use_batch
+          SERVER_URL[@server_zone][BATCH]
+        else
+          SERVER_URL[@server_zone][HTTP_V2]
+        end)
+    end
+
+    def server_url=(url)
+      @url = url
+    end
+
+    def options
+      { 'min_id_length' => @min_id_length } if min_id_length_valid? && @min_id_length
+    end
+
+    def increase_flush_divider
+      @flush_size_divider += 1
+    end
+
+    def reset_flush_divider
+      @flush_size_divider = 1
+    end
+  end
+end

data/lib/amplitude/constants.rb

@@ -0,0 +1,45 @@
+module AmplitudeAnalytics
+  SDK_LIBRARY = 'amplitude-experiment-ruby'.freeze
+  SDK_VERSION = '1.1.5'.freeze
+
+  EU_ZONE = 'EU'.freeze
+  DEFAULT_ZONE = 'US'.freeze
+  BATCH = 'batch'.freeze
+  HTTP_V2 = 'v2'.freeze
+  SERVER_URL = {
+    EU_ZONE => {
+      BATCH => 'https://api.eu.amplitude.com/batch',
+      HTTP_V2 => 'https://api.eu.amplitude.com/2/httpapi'
+    },
+    DEFAULT_ZONE => {
+      BATCH => 'https://api2.amplitude.com/batch',
+      HTTP_V2 => 'https://api2.amplitude.com/2/httpapi'
+    }
+  }.freeze
+  LOGGER_NAME = 'amplitude'.freeze
+
+  MAX_PROPERTY_KEYS = 1024
+  MAX_STRING_LENGTH = 1024
+  FLUSH_QUEUE_SIZE = 200
+  FLUSH_INTERVAL_MILLIS = 10_000
+  FLUSH_MAX_RETRIES = 12
+  CONNECTION_TIMEOUT = 10.0 # seconds float
+  MAX_BUFFER_CAPACITY = 20_000
+
+  # PluginType
+  class PluginType
+    BEFORE = 0
+    ENRICHMENT = 1
+    DESTINATION = 2
+
+    def self.name(value)
+      mapping = {
+        BEFORE => 'BEFORE',
+        ENRICHMENT => 'ENRICHMENT',
+        DESTINATION => 'DESTINATION'
+      }
+
+      mapping[value]
+    end
+  end
+end

data/lib/amplitude/event.rb

@@ -0,0 +1,244 @@
+require 'json'
+
+module AmplitudeAnalytics
+  # IngestionMetadata
+  class IngestionMetadata
+    INGESTION_METADATA_KEY_MAPPING = {
+      'source_name' => ['source_name', String],
+      'source_version' => ['source_version', String]
+    }.freeze
+
+    attr_accessor :source_name, :source_version
+
+    def initialize(source_name: nil, source_version: nil)
+      @source_name = source_name
+      @source_version = source_version
+    end
+
+    def body
+      result = {}
+      INGESTION_METADATA_KEY_MAPPING.each do |key, mapping|
+        next unless instance_variable_defined?("@#{key}") && !instance_variable_get("@#{key}").nil?
+
+        value = instance_variable_get("@#{key}")
+        if value.is_a?(mapping[1])
+          result[mapping[0]] = value
+        else
+          puts "#{self.class}.#{key} expected #{mapping[1]} but received #{value.class}."
+        end
+      end
+      result
+    end
+  end
+
+  # EventOptions
+  class EventOptions
+    EVENT_KEY_MAPPING = {
+      'user_id' => ['user_id', String],
+      'device_id' => ['device_id', String],
+      'event_type' => ['event_type', String],
+      'time' => ['time', Integer],
+      'event_properties' => ['event_properties', Hash],
+      'user_properties' => ['user_properties', Hash],
+      'groups' => ['groups', Hash],
+      'app_version' => ['app_version', String],
+      'platform' => ['platform', String],
+      'os_name' => ['os_name', String],
+      'os_version' => ['os_version', String],
+      'device_brand' => ['device_brand', String],
+      'device_manufacturer' => ['device_manufacturer', String],
+      'device_model' => ['device_model', String],
+      'carrier' => ['carrier', String],
+      'country' => ['country', String],
+      'region' => ['region', String],
+      'city' => ['city', String],
+      'dma' => ['dma', String],
+      'language' => ['language', String],
+      'price' => ['price', Float],
+      'quantity' => ['quantity', Integer],
+      'revenue' => ['revenue', Float],
+      'product_id' => ['productId', String],
+      'revenue_type' => ['revenueType', String],
+      'location_lat' => ['location_lat', Float],
+      'location_lng' => ['location_lng', Float],
+      'ip' => ['ip', String],
+      'idfa' => ['idfa', String],
+      'idfv' => ['idfv', String],
+      'adid' => ['adid', String],
+      'android_id' => ['android_id', String],
+      'event_id' => ['event_id', Integer],
+      'session_id' => ['session_id', Integer],
+      'insert_id' => ['insert_id', String],
+      'library' => ['library', String],
+      'ingestion_metadata' => ['ingestion_metadata', IngestionMetadata],
+      'group_properties' => ['group_properties', Hash],
+      'partner_id' => ['partner_id', String],
+      'version_name' => ['version_name', String]
+    }.freeze
+
+    attr_accessor :user_id, :device_id, :event_type, :time, :event_properties, :user_properties,
+                  :groups, :app_version, :platform, :os_name, :os_version, :device_brand,
+                  :device_manufacturer, :device_model, :carrier, :country, :region, :city,
+                  :dma, :language, :price, :quantity, :revenue, :product_id, :revenue_type,
+                  :location_lat, :location_lng, :ip, :idfa, :idfv, :adid, :android_id,
+                  :event_id, :session_id, :insert_id, :library, :ingestion_metadata,
+                  :group_properties, :partner_id, :version_name, :retry
+
+    def initialize(user_id: nil, device_id: nil, time: nil, event_properties: nil,
+                   user_properties: nil, groups: nil, app_version: nil, platform: nil, os_name: nil,
+                   os_version: nil, device_brand: nil, device_manufacturer: nil, device_model: nil,
+                   carrier: nil, country: nil, region: nil, city: nil, dma: nil, language: nil,
+                   price: nil, quantity: nil, revenue: nil, product_id: nil, revenue_type: nil,
+                   location_lat: nil, location_lng: nil, ip: nil, idfa: nil, idfv: nil, adid: nil,
+                   android_id: nil, event_id: nil, session_id: nil, insert_id: nil,
+                   ingestion_metadata: nil, group_properties: nil, partner_id: nil, version_name: nil,
+                   callback: nil)
+      @user_id = user_id
+      @device_id = device_id
+      @event_type = event_type
+      @time = time
+      @event_properties = event_properties
+      @user_properties = user_properties
+      @groups = groups
+      @app_version = app_version
+      @platform = platform
+      @os_name = os_name
+      @os_version = os_version
+      @device_brand = device_brand
+      @device_manufacturer = device_manufacturer
+      @device_model = device_model
+      @carrier = carrier
+      @country = country
+      @region = region
+      @city = city
+      @dma = dma
+      @language = language
+      @price = price
+      @quantity = quantity
+      @revenue = revenue
+      @product_id = product_id
+      @revenue_type = revenue_type
+      @location_lat = location_lat
+      @location_lng = location_lng
+      @ip = ip
+      @idfa = idfa
+      @idfv = idfv
+      @adid = adid
+      @android_id = android_id
+      @event_id = event_id
+      @session_id = session_id
+      @insert_id = insert_id
+      @ingestion_metadata = ingestion_metadata
+      @group_properties = group_properties
+      @partner_id = partner_id
+      @version_name = version_name
+      @event_callback = callback
+      @retry = 0
+    end
+
+    def [](key)
+      instance_variable_get("@#{key}")
+    end
+
+    def []=(key, value)
+      send("#{key}=", value) if verify_property(key, value)
+    end
+
+    def include?(key)
+      instance_variable_defined?("@#{key}") && !instance_variable_get("@#{key}").nil?
+    end
+
+    def valid_properties?(key, value)
+      return false unless key.is_a?(String)
+
+      if value.is_a?(Array)
+        result = true
+        value.each do |element|
+          return false if element.is_a?(Array)
+
+          if element.is_a?(Hash)
+            result &&= valid_object?(element)
+          elsif !element.is_a?(Numeric) && !element.is_a?(String) && !element.is_a?(TrueClass) && !element.is_a?(FalseClass)
+            result = false
+          end
+          break unless result
+        end
+        return result
+      end
+
+      return valid_object?(value) if value.is_a?(Hash)
+
+      value.is_a?(TrueClass) || value.is_a?(FalseClass) ||
+        value.is_a?(Numeric) || value.is_a?(String) || value.is_a?(Symbol)
+    end
+
+    def valid_object?(obj)
+      obj.each do |key, value|
+        return false unless valid_properties?(key, value)
+      end
+      true
+    end
+
+    def verify_property(key, value)
+      return true if value.nil?
+
+      unless instance_variable_defined?("@#{key}")
+        AmplitudeAnalytics.logger.error("Unexpected event property key: #{key}")
+        return false
+      end
+
+      expected_type = EVENT_KEY_MAPPING[key][1]
+      unless value.is_a?(expected_type)
+        AmplitudeAnalytics.logger.error("Event property #{key} expected #{expected_type} but received #{value.class}.")
+        return false
+      end
+
+      return valid_object?(value) if value.is_a?(Hash)
+
+      true
+    end
+
+    def event_body
+      event_body = {}
+      EVENT_KEY_MAPPING.each do |key, mapping|
+        next unless include?(key) && self[key]
+
+        value = self[key]
+        if value.is_a?(mapping[1])
+          event_body[mapping[0]] = value
+        else
+          puts "#{self.class}.#{key} expected #{mapping[1]} but received #{value.class}."
+        end
+      end
+      event_body['ingestion_metadata'] = @ingestion_metadata.body if @ingestion_metadata.respond_to?(:body)
+      %w[user_properties event_properties group_properties].each do |properties|
+        next unless event_body[properties]
+      end
+      AmplitudeAnalytics.truncate(event_body.sort.to_h)
+    end
+
+    def callback(status_code, message = nil)
+      @event_callback.call(self, status_code, message) if @event_callback.respond_to?(:call)
+    end
+
+    def to_s
+      JSON.generate(event_body)
+    end
+  end
+
+  # BaseEvent
+  class BaseEvent < EventOptions
+    def initialize(event_type, **kwargs)
+      @event_type = event_type
+      super(**kwargs)
+    end
+
+    def load_event_options(event_options)
+      return if event_options.nil?
+
+      EVENT_KEY_MAPPING.each_key do |key|
+        self[key] = Marshal.load(Marshal.dump(event_options[key])) if event_options.include?(key)
+      end
+    end
+  end
+end

data/lib/amplitude/exception.rb

@@ -0,0 +1,15 @@
+module AmplitudeAnalytics
+  # InvalidEventError
+  class InvalidEventError < StandardError
+    def initialize(message = 'Invalid event.')
+      super(message)
+    end
+  end
+
+  # InvalidAPIKeyError
+  class InvalidAPIKeyError < StandardError
+    def initialize(message = 'Invalid API key.')
+      super(message)
+    end
+  end
+end

data/lib/amplitude/http_client.rb

@@ -0,0 +1,161 @@
+require 'json'
+require 'net/http'
+require 'uri'
+
+module AmplitudeAnalytics
+  JSON_HEADER = {
+    'Content-Type': 'application/json; charset=UTF-8',
+    Accept: '*/*'
+  }.freeze
+
+  # HttpStatus
+  class HttpStatus
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    SUCCESS = new(200)
+    INVALID_REQUEST = new(400)
+    TIMEOUT = new(408)
+    PAYLOAD_TOO_LARGE = new(413)
+    TOO_MANY_REQUESTS = new(429)
+    FAILED = new(500)
+    UNKNOWN = new(-1)
+  end
+
+  # Response
+  class Response
+    attr_accessor :status, :code, :body
+
+    def initialize(status: HttpStatus::UNKNOWN, body: nil)
+      @status = status
+      @code = status.value
+      @body = body || {}
+    end
+
+    def parse(res)
+      res_body = JSON.parse(res.body)
+      @code = res_body['code']
+      @status = get_status(@code)
+      @body = res_body
+      self
+    end
+
+    def get_status(code)
+      case code
+      when 200
+        HttpStatus::SUCCESS
+      when 400
+        HttpStatus::INVALID_REQUEST
+      when 408
+        HttpStatus::TIMEOUT
+      when 413
+        HttpStatus::PAYLOAD_TOO_LARGE
+      when 429
+        HttpStatus::TOO_MANY_REQUESTS
+      when 500
+        HttpStatus::FAILED
+      else
+        HttpStatus::UNKNOWN
+      end
+    end
+
+    def error
+      @body['error'] if @body.key?('error')
+    end
+
+    def missing_field
+      @body['missing_field'] if @body.key?('missing_field')
+    end
+
+    def events_with_invalid_fields
+      @body['events_with_invalid_fields'] if @body.key?('events_with_invalid_fields')
+    end
+
+    def events_with_missing_fields
+      @body['events_with_missing_fields'] if @body.key?('events_with_missing_fields')
+    end
+
+    def events_with_invalid_id_lengths
+      @body['events_with_invalid_id_lengths'] if @body.key?('events_with_invalid_id_lengths')
+    end
+
+    def silenced_events
+      @body['silenced_events'] if @body.key?('silenced_events')
+    end
+
+    def throttled_events
+      @body['throttled_events'] if @body.key?('throttled_events')
+    end
+
+    def exceed_daily_quota(event)
+      return true if @body.key?('exceeded_daily_quota_users') && @body['exceeded_daily_quota_users'].include?(event.user_id)
+      return true if @body.key?('exceeded_daily_quota_devices') && @body['exceeded_daily_quota_devices'].include?(event.device_id)
+
+      false
+    end
+
+    def invalid_or_silenced_index
+      result = Set.new
+      result.merge(@body['events_with_missing_fields'].values.flatten) if @body.key?('events_with_missing_fields')
+      result.merge(@body['events_with_invalid_fields'].values.flatten) if @body.key?('events_with_invalid_fields')
+      result.merge(@body['events_with_invalid_id_lengths'].values.flatten) if @body.key?('events_with_invalid_id_lengths')
+      result.merge(@body['silenced_events']) if @body.key?('silenced_events')
+      result.to_a
+    end
+
+    def self.get_status(code)
+      case code
+      when 200..299
+        HttpStatus::SUCCESS
+      when 429
+        HttpStatus::TOO_MANY_REQUESTS
+      when 413
+        HttpStatus::PAYLOAD_TOO_LARGE
+      when 408
+        HttpStatus::TIMEOUT
+      when 400..499
+        HttpStatus::INVALID_REQUEST
+      when 500..Float::INFINITY
+        HttpStatus::FAILED
+      else
+        HttpStatus::UNKNOWN
+      end
+    end
+  end
+
+  # HttpClient
+  class HttpClient
+    def post(url, payload, header = nil)
+      result = Response.new
+      begin
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host || '', uri.port)
+        http.use_ssl = uri.scheme == 'https'
+
+        headers = header || JSON_HEADER
+        request = Net::HTTP::Post.new(uri.request_uri, headers)
+        request.body = payload
+        res = http.request(request)
+        result.parse(res)
+      rescue Net::ReadTimeout
+        result.code = 408
+        result.status = HttpStatus::TIMEOUT
+      rescue Net::HTTPError => e
+        begin
+          result.parse(e)
+        rescue StandardError
+          result = Response.new
+          result.code = e.response.code.to_i
+          result.status = Response.get_status(e.response.code.to_i)
+          result.body = { 'error' => e.response.message }
+        end
+      rescue Net::OpenTimeout => e
+        result.body = { 'error' => e.message }
+      end
+      result
+    end
+  end
+end