itly-plugin-iteratively 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e2c1016650bf9c0d05a4e662f4a15b6eb14a125416fdb362e69c0fc433cd531a
+  data.tar.gz: 40c0b7f79658aed2cd2be23565c9e440389bb4f772fce4bfa8c473897a055f4b
+SHA512:
+  metadata.gz: 33d0b5132356ad3a88d896d347e67b3af337aefd3c2f21c16f67843436c013279a5bde132720a01193ba10a69a886c22cbf53b2c959bfa16c1c6e0481e3366f3
+  data.tar.gz: 9b16bbc696d83b861669303b96067d50864292218328bc2e66057e1078d5da7c9d7fa2e40778ca92d86cacca02bafb92ad5efa4dd7940a212ba180415b93b33f

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in itly-plugin-iteratively.gemspec
+gemspec
+
+gem 'rake', '~> 13.0'
+
+if ENV['LOCAL_ITLY_GEM']
+  # TODO: before publication to RubyGems, switch to version 1
+  gem 'itly-sdk', '~> 0.1', path: '../sdk'
+end
+
+gem 'rbs', '~> 1.0'
+gem 'rspec'
+gem 'steep', '~> 0.41'

data/Steepfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+target :lib do
+  signature 'sig'
+
+  check 'lib'
+
+  library 'logger', 'set', 'itly-sdk'
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'itly/plugin-iteratively'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/rspec

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Configure and load RBS
+unless ENV['DISABLE_TYPE_CHECKING']
+  ENV['RBS_TEST_TARGET'] = 'Itly::*'
+  ENV['RBS_TEST_LOGLEVEL'] = 'warn'
+  ENV['RBS_TEST_DOUBLE_SUITE'] = 'rspec'
+  ENV['RBS_TEST_OPT'] = '-I./sig -I../sdk/sig'
+
+  require 'rbs/test/setup'
+end
+
+# Start RSpec
+require 'rspec/core'
+
+ENV['RSPEC_RUN_FROM_SCRIPT'] = 'true'
+RSpec::Core::Runner.invoke

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/itly-plugin-iteratively.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'lib/itly/plugin/iteratively/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'itly-plugin-iteratively'
+  spec.version       = Itly::Plugin::Iteratively::VERSION
+  spec.authors       = ['Iteratively', 'Benjamin Bouchet', 'Justin Fiedler', 'Andrey Sokolov']
+  spec.email         = ['support@iterative.ly']
+
+  spec.summary       = 'Iteratively plugin for Iteratively SDK for Ruby'
+  spec.description   = 'Track and validate analytics with a unified, extensible interface ' \
+                       'that works with all your 3rd party analytics providers.'
+  spec.homepage      = 'https://github.com/iterativelyhq/itly-sdk-ruby'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.6.0')
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org/'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/iterativelyhq/itly-sdk-ruby/plugin-iteratively'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'concurrent-ruby', '~> 1.1'
+  spec.add_dependency 'faraday', '~> 1.3'
+end

data/lib/itly/plugin-iteratively.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+if ENV['LOCAL_ITLY_GEM']
+  lib = File.expand_path('../../../sdk/lib', File.dirname(__FILE__))
+  $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+end
+
+require_relative 'plugin/iteratively/iteratively'
+require_relative 'plugin/iteratively/options'
+require_relative 'plugin/iteratively/track_type'
+require_relative 'plugin/iteratively/track_model'
+require_relative 'plugin/iteratively/client'
+require_relative 'plugin/iteratively/version'

data/lib/itly/plugin/iteratively/client.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+require 'faraday'
+require 'itly-sdk'
+
+class Itly
+  class Plugin
+    class Iteratively
+      ##
+      # HTTP client for the plugin requests
+      #
+      class Client
+        attr_reader :api_key, :url, :logger, :flush_queue_size, :batch_size, :flush_interval_ms, :max_retries,
+          :retry_delay_min, :retry_delay_max, :omit_values, :branch, :version
+
+        def initialize(
+          url:, api_key:, logger:, flush_queue_size:, batch_size:, flush_interval_ms:, max_retries:,
+          retry_delay_min:, retry_delay_max:, omit_values:, branch:, version:
+        )
+          @buffer = ::Concurrent::Array.new
+          @runner = @scheduler = nil
+
+          @api_key = api_key
+          @url = url
+          @logger = logger
+          @flush_queue_size = flush_queue_size
+          @batch_size = batch_size
+          @flush_interval_ms = flush_interval_ms
+          @max_retries = max_retries
+          @retry_delay_min = retry_delay_min
+          @retry_delay_max = retry_delay_max
+          @omit_values = omit_values
+          @branch = branch
+          @version = version
+
+          # Start the scheduler
+          start_scheduler
+        end
+
+        def track(type:, event:, properties:, validation:)
+          @buffer << ::Itly::Plugin::Iteratively::TrackModel.new(
+            omit_values: omit_values, type: type, event: event, properties: properties, validation: validation
+          )
+
+          flush if buffer_full?
+        end
+
+        def flush
+          # Case: the runner is on, cannot call flush again
+          return unless runner_complete?
+
+          # Exit if there is nothing to do
+          return if @buffer.empty?
+
+          # Extract the current content of the buffer for processing
+          processing = @buffer.each_slice(@batch_size).to_a
+          @buffer.clear
+
+          # Run in the background
+          @runner = Concurrent::Future.new do
+            processing.each do |batch|
+              # Initialization before the loop starts
+              tries = 0
+
+              loop do
+                # Count the number of tries
+                tries += 1
+
+                # Case: successfully sent
+                break if post_models batch
+
+                # Case: could not sent and reached maximum number of allowed tries
+                if tries >= @max_retries
+                  # Log
+                  logger&.error 'Iteratively::Client: flush() reached maximum number of tries. '\
+                    "#{batch.count} events won't be sent to the server"
+
+                  # Discard the list of event in the batch queue
+                  break
+
+                # Case: could not sent and wait before retrying
+                else
+                  sleep delay_before_next_try(tries)
+                end
+              end
+            end
+          end
+
+          @runner.execute
+        end
+
+        def shutdown(force: false)
+          @scheduler&.cancel
+
+          if force
+            @runner&.cancel
+            return
+          end
+
+          @max_retries = 0
+          flush
+          @runner&.wait_or_cancel @retry_delay_min
+        end
+
+        private
+
+        def buffer_full?
+          @buffer.length >= @flush_queue_size
+        end
+
+        def post_models(models)
+          data = {
+            branchName: @branch,
+            trackingPlanVersion: @version,
+            objects: models
+          }.to_json
+          headers = {
+            'Content-Type' => 'application/json',
+            'authorization' => "Bearer #{@api_key}"
+          }
+          resp = Faraday.post(@url, data, headers)
+
+          # Case: HTTP response 2xx is a Success
+          return true if (200...300).include? resp.status
+
+          # Case: Error
+          logger&.error "Iteratively::Client: post_models() unexpected response. Url: #{url} "\
+            "Data: #{data} Response status: #{resp.status} Response headers: #{resp.headers} "\
+            "Response body: #{resp.body}"
+          false
+        rescue StandardError => e
+          logger&.error "Iteratively::Client: post_models() exception #{e.class.name}: #{e.message}"
+          false
+        end
+
+        def runner_complete?
+          @runner.nil? || @runner.complete?
+        end
+
+        # Generates progressively increasing values to wait between client calls
+        # For max_retries: 25, retry_delay_min: 10.0, retry_delay_max: 3600.0, generated values are:
+        # 10, 18, 41, 79, 132, 201, 283, 380, 491, 615, 752, 901, 1061, 1233, 1415, 1606,
+        # 1805, 2012, 2226, 2446, 2671, 2900, 3131, 3365, 3600
+        def delay_before_next_try(nbr_tries)
+          percent = (nbr_tries - 1).to_f / (@max_retries - 1)
+          rad = percent * Math::PI / 2
+          delta = (Math.cos(rad) - 1).abs
+
+          retry_delay_min + delta * (@retry_delay_max - @retry_delay_min)
+        end
+
+        def start_scheduler
+          @scheduler = Concurrent::ScheduledTask.new(@flush_interval_ms / 1000.0) do
+            flush unless runner_complete?
+            start_scheduler
+          end
+          @scheduler.execute
+        end
+      end
+    end
+  end
+end

data/lib/itly/plugin/iteratively/iteratively.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'itly-sdk'
+
+class Itly
+  class Plugin
+    ##
+    # Iteratively plugin class for Itly SDK
+    #
+    # Automatically loaded at runtime in any new +Itly+ object
+    #
+    class Iteratively < Plugin
+      attr_reader :logger, :disabled, :client, :url, :api_key
+
+      ##
+      # Instantiate a new Plugin::Iteratively
+      #
+      # @param [String] api_key: specify the api key
+      # @param [Itly::Plugin::Iteratively::Options] options: options object. See +Itly::Plugin::Iteratively::Options+
+      #
+      def initialize(api_key:, options:)
+        super()
+        @api_key = api_key
+        @url = options.url
+        @disabled = options.disabled
+
+        @client_options = {
+          flush_queue_size: options.flush_queue_size,
+          batch_size: options.batch_size,
+          flush_interval_ms: options.flush_interval_ms,
+          max_retries: options.max_retries,
+          retry_delay_min: options.retry_delay_min,
+          retry_delay_max: options.retry_delay_max,
+          omit_values: options.omit_values,
+          branch: options.branch,
+          version: options.version
+        }
+      end
+
+      ##
+      # Initialize IterativelyApi client
+      #
+      # The plugin is automatically disabled in Production
+      #
+      # @param [Itly::PluginOptions] options: plugin options
+      #
+      def load(options:)
+        super
+        # Get options
+        @logger = options.logger
+
+        # Log
+        logger&.info "#{id}: load()"
+
+        # Disabled
+        @disabled = options.environment == Itly::Options::Environment::PRODUCTION if @disabled.nil?
+
+        if @disabled
+          logger&.info "#{id}: plugin is disabled!"
+          return
+        end
+
+        # Client
+        @client_options.merge! url: @url, api_key: @api_key, logger: @logger
+        @client = Itly::Plugin::Iteratively::Client.new(**@client_options)
+      end
+
+      def post_identify(user_id:, properties:, validation_results:)
+        super
+        return unless enabled?
+
+        # Log
+        log = Itly::Loggers.vars_to_log user_id: user_id, properties: properties, validation_results: validation_results
+        logger&.info "#{id}: post_identify(#{log})"
+
+        client_track Itly::Plugin::Iteratively::TrackType::IDENTIFY, properties, validation_results
+      end
+
+      def post_group(user_id:, group_id:, properties:, validation_results:)
+        super
+        return unless enabled?
+
+        # Log
+        log = Itly::Loggers.vars_to_log(
+          user_id: user_id, group_id: group_id, properties: properties, validation_results: validation_results
+        )
+        logger&.info "#{id}: post_group(#{log})"
+
+        client_track Itly::Plugin::Iteratively::TrackType::GROUP, properties, validation_results
+      end
+
+      def post_track(user_id:, event:, validation_results:)
+        super
+        return unless enabled?
+
+        # Log
+        log = Itly::Loggers.vars_to_log user_id: user_id, event: event, validation_results: validation_results
+        logger&.info "#{id}: post_track(#{log})"
+
+        client_track Itly::Plugin::Iteratively::TrackType::TRACK, event, validation_results
+      end
+
+      def flush
+        @client.flush
+      end
+
+      def shutdown(force: false)
+        @client.shutdown force: force
+      end
+
+      ##
+      # Get the plugin ID
+      #
+      # @return [String] plugin id
+      #
+      def id
+        'iteratively'
+      end
+
+      private
+
+      def enabled?
+        !@disabled
+      end
+
+      def client_track(type, event_or_properties, validations)
+        event = event_or_properties.is_a?(Itly::Event) ? event_or_properties : nil
+        properties = event_or_properties.is_a?(Hash) ? event_or_properties : nil
+        validation = (validations || []).reject(&:valid).first
+        @client.track type: type, event: event, properties: properties, validation: validation
+      end
+    end
+  end
+end

data/lib/itly/plugin/iteratively/options.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'itly-sdk'
+
+class Itly
+  class Plugin
+    class Iteratively
+      ##
+      # Options for the Iteratively plugin class
+      #
+      class Options
+        DEFAULT_URL = 'https://data.us-east-2.iterative.ly/t'
+
+        attr_reader :url, :disabled, :flush_queue_size, :batch_size, :flush_interval_ms, :max_retries,
+          :retry_delay_min, :retry_delay_max, :omit_values, :branch, :version
+
+        ##
+        # Instantiate a new Options
+        #
+        # @param [String] url (optional): specify the url to push events to.
+        #   Default to https://data.us-east-2.iterative.ly/t
+        # @param [TrueClass/FalseClass] disabled: set to true to disable the Iteratively plugin.
+        #   Default to +true+ in production environment, to +false+ otherwise
+        # @param [Integer] flush_queue_size (optional): Number of event in the buffer before
+        #   a flush is triggered. Default: 10
+        # @param [Integer] batch_size (optional): Maximum number of events to send to the server at once. Default: 100
+        # @param [Integer] flush_interval_ms (optional): Delay in milliseconds between each automatic
+        #   flush. Default: 1_000
+        # @param [Integer] max_retries (optional): Number of retries for pushing
+        #   events to the server. Default: 25
+        # @param [Float] retry_delay_min: Minimum delay between retries in seconds. Default: 10.0
+        # @param [Float] retry_delay_max: Maximum delay between retries in seconds. Default: 3600.0 (1 hour)
+        # @param [TrueClass/FalseClass] omit_values: set to true to send empty data. Default to false
+        # @param [String] branch: Tracking plan branch name (e.g. feature/demo)
+        # @param [String] version: Tracking plan version number (e.g. 1.0.0)
+        #
+        def initialize(
+          url: DEFAULT_URL, disabled: nil, flush_queue_size: 10, batch_size: 100, flush_interval_ms: 1_000,
+          max_retries: 25, retry_delay_min: 10.0, retry_delay_max: 3600.0, omit_values: false, branch: nil, version: nil
+        )
+          super()
+          @url = url
+          @disabled = disabled
+          @flush_queue_size = flush_queue_size
+          @batch_size = batch_size
+          @flush_interval_ms = flush_interval_ms
+          @max_retries = max_retries
+          @retry_delay_min = retry_delay_min
+          @retry_delay_max = retry_delay_max
+          @omit_values = omit_values
+          @branch = branch
+          @version = version
+        end
+
+        ##
+        # Returns a copy of this Options with any provided arguments used as overrides
+        #
+        def with_overrides(
+          url: nil, disabled: nil, flush_queue_size: nil, batch_size: nil, flush_interval_ms: nil,
+          max_retries: nil, retry_delay_min: nil, retry_delay_max: nil, omit_values: nil, branch: nil, version: nil
+        )
+          Itly::Plugin::Iteratively::Options.new(
+            url: url.nil? ? @url : url,
+            disabled: disabled.nil? ? @disabled : disabled,
+            flush_queue_size: flush_queue_size.nil? ? @flush_queue_size : flush_queue_size,
+            batch_size: batch_size.nil? ? @batch_size : batch_size,
+            flush_interval_ms: flush_interval_ms.nil? ? @flush_interval_ms : flush_interval_ms,
+            max_retries: max_retries.nil? ? @max_retries : max_retries,
+            retry_delay_min: retry_delay_min.nil? ? @retry_delay_min : retry_delay_min,
+            retry_delay_max: retry_delay_max.nil? ? @retry_delay_max : retry_delay_max,
+            omit_values: omit_values.nil? ? @omit_values : omit_values,
+            branch: branch.nil? ? @branch : branch,
+            version: version.nil? ? @version : version
+          )
+        end
+      end
+    end
+  end
+end

data/lib/itly/plugin/iteratively/track_model.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'json'
+require 'itly-sdk'
+
+class Itly
+  class Plugin
+    class Iteratively
+      ##
+      # Data model for HTTP client buffering
+      #
+      class TrackModel
+        attr_reader :type, :date_sent, :event_id, :event_schema_version, :event_name,
+          :properties, :valid, :validation
+
+        def initialize(type:, event:, properties:, validation: nil, omit_values: false)
+          @omit_values = omit_values
+          @type = type
+          @date_sent = Time.now.utc.iso8601
+          @event_id = event&.id
+          @event_schema_version = event&.version
+          @event_name = event&.name
+          @properties = event&.properties || properties
+          @valid = validation ? validation.valid : true
+          @validation = { details: validation ? validation.message : '' }
+
+          @properties = @properties.transform_values { |_| '' } if @omit_values
+        end
+
+        def to_json(*_)
+          {
+            type: @type,
+            dateSent: @date_sent,
+            eventId: @event_id,
+            eventSchemaVersion: @event_schema_version,
+            eventName: @event_name,
+            properties: @properties,
+            valid: @valid,
+            validation: @validation
+          }.to_json
+        end
+
+        def to_s
+          "#<#{self.class.name}: type: #{@type} date_sent: #{@date_sent} event_id: #{@event_id} "\
+            "event_schema_version: #{@event_schema_version} event_name: #{@event_name} "\
+            "properties: #{@properties} valid: #{@valid} validation: #{@validation}>"
+        end
+      end
+    end
+  end
+end

data/lib/itly/plugin/iteratively/track_type.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Itly
+  class Plugin
+    class Iteratively
+      ##
+      # This module contains values for the +type+ of tracked events by the Client
+      #
+      module TrackType
+        GROUP = 'group'
+        IDENTIFY = 'identify'
+        TRACK = 'track'
+      end
+    end
+  end
+end

data/lib/itly/plugin/iteratively/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Itly
+  class Plugin
+    class Iteratively < Plugin
+      VERSION = '0.1.0'
+    end
+  end
+end

data/sig/client.rbs

@@ -0,0 +1,31 @@
+class Itly
+  class Plugin
+    class Iteratively
+      class Client
+        attr_reader api_key: String
+        attr_reader url: String
+        attr_reader logger: Logger?
+        attr_reader flush_queue_size: Integer
+        attr_reader batch_size: Integer
+        attr_reader flush_interval_ms: Integer
+        attr_reader max_retries: Integer
+        attr_reader retry_delay_min: Float
+        attr_reader retry_delay_max: Float
+        attr_reader branch: String?
+        attr_reader version: String?
+
+        def track: (type: String `type`, event: Itly::Event? event, properties: propertiesHash? properties, validation: Itly::ValidationResponse? validation) -> void
+        def flush: () -> void
+        def shutdown: (?force: bool force) -> void
+
+        private
+
+        def initialize: (url: String url, api_key: String api_key, logger: Logger? logger, flush_queue_size: Integer flush_queue_size, batch_size: Integer batch_size, flush_interval_ms: Integer flush_interval_ms, max_retries: Integer max_retries, retry_delay_min: Float retry_delay_min, retry_delay_max: Float retry_delay_max, omit_values: bool omit_values, branch: String? branch, version: String? version) -> void
+        def buffer_full?: () -> bool
+        def post_models: (Array[Itly::Plugin::Iteratively::TrackModel] model) -> bool
+        def runner_complete?: () -> bool
+        def delay_before_next_try: (Integer nbr_tries) -> Float
+      end
+    end
+  end
+end

data/sig/iteratively.rbs

@@ -0,0 +1,27 @@
+class Itly
+  class Plugin
+    class Iteratively < Plugin
+      VERSION: String
+
+      attr_reader logger: Logger?
+      attr_reader disabled: bool?
+      attr_reader client: Itly::Plugin::Iteratively::Client?
+      attr_reader url: String
+      attr_reader api_key: String
+
+      def load: (options: Itly::PluginOptions options) -> void
+      def post_identify: (user_id: String user_id, properties: propertiesHash properties, validation_results: Array[Itly::ValidationResponse] validation_results) -> void
+      def post_group: (user_id: String user_id, group_id: String group_id, properties: propertiesHash properties, validation_results: Array[Itly::ValidationResponse] validation_results) -> void
+      def post_track: (user_id: String user_id, event: Itly::Event event, validation_results: Array[Itly::ValidationResponse] validation_results) -> void
+      def flush: () -> void
+      def shutdown: (?force: bool force) -> void
+      def id: () -> String
+
+      private
+
+      def initialize: (api_key: String api_key, options: Itly::Plugin::Iteratively::Options options) -> void
+      def enabled?: () -> bool
+      def client_track: (String `type`, Itly::Event|propertiesHash event_or_properties, Array[Itly::ValidationResponse]? validations) -> void
+    end
+  end
+end

data/sig/options.rbs

@@ -0,0 +1,25 @@
+class Itly
+  class Plugin
+    class Iteratively
+      class Options
+        DEFAULT_URL: String
+
+        attr_reader url: String
+        attr_reader disabled: bool?
+        attr_reader flush_queue_size: Integer
+        attr_reader batch_size: Integer
+        attr_reader flush_interval_ms: Integer
+        attr_reader max_retries: Integer
+        attr_reader retry_delay_min: Float
+        attr_reader retry_delay_max: Float
+        attr_reader omit_values: bool
+        attr_reader branch: String?
+        attr_reader version: String?
+
+        private
+
+        def initialize: (?url: String url, ?disabled: bool? disabled, ?flush_queue_size: Integer flush_queue_size, ?batch_size: Integer batch_size, ?flush_interval_ms: Integer flush_interval_ms, ?max_retries: Integer max_retries, ?retry_delay_min: Float retry_delay_min, ?retry_delay_max: Float retry_delay_max, ?omit_values: bool omit_values, ?branch: String? branch, ?version: String? version) -> void
+      end
+    end
+  end
+end

data/sig/track_model.rbs

@@ -0,0 +1,23 @@
+class Itly
+  class Plugin
+    class Iteratively
+      class TrackModel
+        attr_reader type: String
+        attr_reader date_sent: String
+        attr_reader event_id: String
+        attr_reader event_schema_version: String
+        attr_reader event_name: String
+        attr_reader properties: propertiesHash
+        attr_reader valid: bool?
+        attr_reader validation: Itly::ValidationResponse?
+
+        def to_json: (*untyped _) -> String
+
+        private
+
+        def initialize: (type: String `type`, event: Itly::Event? event, properties: propertiesHash? properties, ?validation: Itly::ValidationResponse? validation, omit_values: bool omit_values) -> void
+        def to_s: () -> String
+      end
+    end
+  end
+end

data/sig/track_type.rbs

@@ -0,0 +1,11 @@
+class Itly
+  class Plugin
+    class Iteratively
+      module TrackType
+        GROUP: String
+        IDENTIFY: String
+        TRACK: String
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: itly-plugin-iteratively
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Iteratively
+- Benjamin Bouchet
+- Justin Fiedler
+- Andrey Sokolov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  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: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Track and validate analytics with a unified, extensible interface that
+  works with all your 3rd party analytics providers.
+email:
+- support@iterative.ly
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- Steepfile
+- bin/console
+- bin/rspec
+- bin/setup
+- itly-plugin-iteratively.gemspec
+- lib/itly/plugin-iteratively.rb
+- lib/itly/plugin/iteratively/client.rb
+- lib/itly/plugin/iteratively/iteratively.rb
+- lib/itly/plugin/iteratively/options.rb
+- lib/itly/plugin/iteratively/track_model.rb
+- lib/itly/plugin/iteratively/track_type.rb
+- lib/itly/plugin/iteratively/version.rb
+- sig/client.rbs
+- sig/iteratively.rbs
+- sig/options.rbs
+- sig/track_model.rbs
+- sig/track_type.rbs
+homepage: https://github.com/iterativelyhq/itly-sdk-ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org/
+  homepage_uri: https://github.com/iterativelyhq/itly-sdk-ruby
+  source_code_uri: https://github.com/iterativelyhq/itly-sdk-ruby/plugin-iteratively
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Iteratively plugin for Iteratively SDK for Ruby
+test_files: []