segment 2.2.5

data/analytics-ruby.gemspec

@@ -0,0 +1,33 @@
+require File.expand_path('../lib/segment/analytics/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name = 'segment'
+  spec.version = Segment::Analytics::VERSION
+  spec.files = Dir.glob('**/*')
+  spec.require_paths = ['lib']
+  spec.bindir = 'bin'
+  spec.executables = ['analytics']
+  spec.summary = 'Segment analytics library'
+  spec.description = 'The Segment ruby analytics library'
+  spec.authors = ['Segment']
+  spec.email = 'friends@segment.com'
+  spec.homepage = 'https://github.com/segmentio/analytics-ruby'
+  spec.license = 'MIT'
+
+  # Ruby 1.8 requires json
+  spec.add_dependency 'json', ['~> 1.7'] if RUBY_VERSION < "1.9"
+  spec.add_dependency 'commander', '~> 4.4'
+
+  spec.add_development_dependency 'rake', '~> 10.3'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'tzinfo', '1.2.1'
+  spec.add_development_dependency 'activesupport', '~> 4.1.11'
+  spec.add_development_dependency 'faraday', '~> 0.13'
+  spec.add_development_dependency 'pmap', '~> 1.1'
+
+  if RUBY_VERSION >= "2.1"
+    spec.add_development_dependency 'rubocop', '~> 0.51.0'
+  end
+
+  spec.add_development_dependency 'codecov', '~> 0.1.4'
+end

data/bin/analytics

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+
+require 'segment/analytics'
+require 'rubygems'
+require 'commander/import'
+require 'time'
+require 'json'
+
+program :name, 'simulator.rb'
+program :version, '0.0.1'
+program :description, 'scripting simulator'
+
+def json_hash(str)
+  if str
+    return JSON.parse(str)
+  end
+end
+
+# analytics -method=<method> -segment-write-key=<segmentWriteKey> [options]
+
+default_command :send
+
+command :send do |c|
+  c.description = 'send a segment message'
+
+  c.option '--writeKey=<writeKey>', String, 'the Segment writeKey'
+  c.option '--type=<type>', String, 'The Segment message type'
+
+  c.option '--userId=<userId>', String, 'the user id to send the event as'
+  c.option '--anonymousId=<anonymousId>', String, 'the anonymous user id to send the event as'
+  c.option '--context=<context>', 'additional context for the event (JSON-encoded)'
+
+  c.option '--event=<event>', String, 'the event name to send with the event'
+  c.option '--properties=<properties>', 'the event properties to send (JSON-encoded)'
+
+  c.option '--name=<name>', 'name of the screen or page to send with the message'
+
+  c.option '--traits=<traits>', 'the identify/group traits to send (JSON-encoded)'
+
+  c.option '--groupId=<groupId>', String, 'the group id'
+
+  c.action do |args, options|
+    Analytics = Segment::Analytics.new({
+      write_key: options.writeKey,
+      on_error: Proc.new { |status, msg| print msg }
+    })
+
+    case options.type
+    when "track"
+      Analytics.track({
+        user_id: options.userId,
+        event: options.event,
+        anonymous_id: options.anonymousId,
+        properties: json_hash(options.properties),
+        context: json_hash(options.context)
+      })
+    when "page"
+      Analytics.page({
+        user_id: options.userId,
+        anonymous_id: options.anonymousId,
+        name: options.name,
+        properties: json_hash(options.properties),
+        context: json_hash(options.context)
+      })
+    when "screen"
+      Analytics.screen({
+        user_id: options.userId,
+        anonymous_id: options.anonymousId,
+        name: option.name,
+        traits: json_hash(options.traits),
+        properties: json_hash(option.properties)
+      })
+    when "identify"
+      Analytics.identify({
+        user_id: options.userId,
+        anonymous_id: options.anonymousId,
+        traits: json_hash(options.traits),
+        context: json_hash(options.context)
+      })
+    when "group"
+      Analytics.group({
+        user_id: options.userId,
+        anonymous_id: options.anonymousId,
+        group_id: options.groupId,
+        traits: json_hash(options.traits),
+        context: json_hash(options.context)
+      })
+    else
+      raise "Invalid Message Type #{options.type}"
+    end
+    Analytics.flush
+  end
+end

data/codecov.yml

@@ -0,0 +1,2 @@
+ignore:
+  - "spec/**/*"

data/lib/analytics-ruby.rb

@@ -0,0 +1 @@
+require 'segment'

data/lib/segment.rb

@@ -0,0 +1 @@
+require 'segment/analytics'

data/lib/segment/analytics.rb

@@ -0,0 +1,38 @@
+require 'segment/analytics/version'
+require 'segment/analytics/defaults'
+require 'segment/analytics/utils'
+require 'segment/analytics/client'
+require 'segment/analytics/worker'
+require 'segment/analytics/request'
+require 'segment/analytics/response'
+require 'segment/analytics/logging'
+
+module Segment
+  class Analytics
+    # Initializes a new instance of {Segment::Analytics::Client}, to which all
+    # method calls are proxied.
+    #
+    # @param options includes options that are passed down to
+    #   {Segment::Analytics::Client#initialize}
+    # @option options [Boolean] :stub (false) If true, requests don't hit the
+    #   server and are stubbed to be successful.
+    def initialize(options = {})
+      Request.stub = options[:stub] if options.has_key?(:stub)
+      @client = Segment::Analytics::Client.new options
+    end
+
+    def method_missing(message, *args, &block)
+      if @client.respond_to? message
+        @client.send message, *args, &block
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @client.respond_to?(method_name) || super
+    end
+
+    include Logging
+  end
+end

data/lib/segment/analytics/backoff_policy.rb

@@ -0,0 +1,49 @@
+require 'segment/analytics/defaults'
+
+module Segment
+  class Analytics
+    class BackoffPolicy
+      include Segment::Analytics::Defaults::BackoffPolicy
+
+      # @param [Hash] opts
+      # @option opts [Numeric] :min_timeout_ms The minimum backoff timeout
+      # @option opts [Numeric] :max_timeout_ms The maximum backoff timeout
+      # @option opts [Numeric] :multiplier The value to multiply the current
+      #   interval with for each retry attempt
+      # @option opts [Numeric] :randomization_factor The randomization factor
+      #   to use to create a range around the retry interval
+      def initialize(opts = {})
+        @min_timeout_ms = opts[:min_timeout_ms] || MIN_TIMEOUT_MS
+        @max_timeout_ms = opts[:max_timeout_ms] || MAX_TIMEOUT_MS
+        @multiplier = opts[:multiplier] || MULTIPLIER
+        @randomization_factor = opts[:randomization_factor] || RANDOMIZATION_FACTOR
+
+        @attempts = 0
+      end
+
+      # @return [Numeric] the next backoff interval, in milliseconds.
+      def next_interval
+        interval = @min_timeout_ms * (@multiplier**@attempts)
+        interval = add_jitter(interval, @randomization_factor)
+
+        @attempts += 1
+
+        [interval, @max_timeout_ms].min
+      end
+
+      private
+
+      def add_jitter(base, randomization_factor)
+        random_number = rand
+        max_deviation = base * randomization_factor
+        deviation = random_number * max_deviation
+
+        if random_number < 0.5
+          base - deviation
+        else
+          base + deviation
+        end
+      end
+    end
+  end
+end

data/lib/segment/analytics/client.rb

@@ -0,0 +1,425 @@
+require 'thread'
+require 'time'
+
+require 'segment/analytics/defaults'
+require 'segment/analytics/logging'
+require 'segment/analytics/utils'
+require 'segment/analytics/worker'
+
+module Segment
+  class Analytics
+    class Client
+      include Segment::Analytics::Utils
+      include Segment::Analytics::Logging
+
+      # @param [Hash] opts
+      # @option opts [String] :write_key Your project's write_key
+      # @option opts [FixNum] :max_queue_size Maximum number of calls to be
+      #   remain queued.
+      # @option opts [Proc] :on_error Handles error calls from the API.
+      def initialize(opts = {})
+        symbolize_keys!(opts)
+
+        @queue = Queue.new
+        @write_key = opts[:write_key]
+        @max_queue_size = opts[:max_queue_size] || Defaults::Queue::MAX_SIZE
+        @options = opts
+        @worker_mutex = Mutex.new
+        @worker = Worker.new(@queue, @write_key, @options)
+
+        check_write_key!
+
+        at_exit { @worker_thread && @worker_thread[:should_exit] = true }
+      end
+
+      # Synchronously waits until the worker has flushed the queue.
+      #
+      # Use only for scripts which are not long-running, and will specifically
+      # exit
+      def flush
+        while !@queue.empty? || @worker.is_requesting?
+          ensure_worker_running
+          sleep(0.1)
+        end
+      end
+
+      # Tracks an event
+      #
+      # @see https://segment.com/docs/sources/server/ruby/#track
+      #
+      # @param [Hash] attrs
+      # @option attrs [String] :anonymous_id ID for a user when you don't know
+      #   who they are yet. (optional but you must provide either an
+      #   `anonymous_id` or `user_id`)
+      # @option attrs [Hash] :context ({})
+      # @option attrs [String] :event Event name
+      # @option attrs [Hash] :integrations What integrations this event
+      #   goes to (optional)
+      # @option attrs [Hash] :options Options such as user traits (optional)
+      # @option attrs [Hash] :properties Event properties (optional)
+      # @option attrs [Time] :timestamp When the event occurred (optional)
+      # @option attrs [String] :user_id The ID for this user in your database
+      #   (optional but you must provide either an `anonymous_id` or `user_id`)
+      # @option attrs [String] :message_id ID that uniquely
+      #   identifies a message across the API. (optional)
+      def track(attrs)
+        symbolize_keys! attrs
+        check_user_id! attrs
+
+        event = attrs[:event]
+        properties = attrs[:properties] || {}
+        timestamp = attrs[:timestamp] || Time.new
+        context = attrs[:context] || {}
+        message_id = attrs[:message_id].to_s if attrs[:message_id]
+
+        check_timestamp! timestamp
+
+        if event.nil? || event.empty?
+          raise ArgumentError, 'Must supply event as a non-empty string'
+        end
+
+        raise ArgumentError, 'Properties must be a Hash' unless properties.is_a? Hash
+        isoify_dates! properties
+
+        add_context context
+
+        enqueue({
+          :event => event,
+          :userId => attrs[:user_id],
+          :anonymousId => attrs[:anonymous_id],
+          :context => context,
+          :options => attrs[:options],
+          :integrations => attrs[:integrations],
+          :properties => properties,
+          :messageId => message_id,
+          :timestamp => datetime_in_iso8601(timestamp),
+          :type => 'track'
+        })
+      end
+
+      # Identifies a user
+      #
+      # @see https://segment.com/docs/sources/server/ruby/#identify
+      #
+      # @param [Hash] attrs
+      # @option attrs [String] :anonymous_id ID for a user when you don't know
+      #   who they are yet. (optional but you must provide either an
+      #   `anonymous_id` or `user_id`)
+      # @option attrs [Hash] :context ({})
+      # @option attrs [Hash] :integrations What integrations this event
+      #   goes to (optional)
+      # @option attrs [Hash] :options Options such as user traits (optional)
+      # @option attrs [Time] :timestamp When the event occurred (optional)
+      # @option attrs [Hash] :traits User traits (optional)
+      # @option attrs [String] :user_id The ID for this user in your database
+      #   (optional but you must provide either an `anonymous_id` or `user_id`)
+      # @option attrs [String] :message_id ID that uniquely identifies a
+      #   message across the API. (optional)
+      def identify(attrs)
+        symbolize_keys! attrs
+        check_user_id! attrs
+
+        traits = attrs[:traits] || {}
+        timestamp = attrs[:timestamp] || Time.new
+        context = attrs[:context] || {}
+        message_id = attrs[:message_id].to_s if attrs[:message_id]
+
+        check_timestamp! timestamp
+
+        raise ArgumentError, 'Must supply traits as a hash' unless traits.is_a? Hash
+        isoify_dates! traits
+
+        add_context context
+
+        enqueue({
+          :userId => attrs[:user_id],
+          :anonymousId => attrs[:anonymous_id],
+          :integrations => attrs[:integrations],
+          :context => context,
+          :traits => traits,
+          :options => attrs[:options],
+          :messageId => message_id,
+          :timestamp => datetime_in_iso8601(timestamp),
+          :type => 'identify'
+        })
+      end
+
+      # Aliases a user from one id to another
+      #
+      # @see https://segment.com/docs/sources/server/ruby/#alias
+      #
+      # @param [Hash] attrs
+      # @option attrs [Hash] :context ({})
+      # @option attrs [Hash] :integrations What integrations this must be
+      #   sent to (optional)
+      # @option attrs [Hash] :options Options such as user traits (optional)
+      # @option attrs [String] :previous_id The ID to alias from
+      # @option attrs [Time] :timestamp When the alias occurred (optional)
+      # @option attrs [String] :user_id The ID to alias to
+      # @option attrs [String] :message_id ID that uniquely identifies a
+      #   message across the API. (optional)
+      def alias(attrs)
+        symbolize_keys! attrs
+
+        from = attrs[:previous_id]
+        to = attrs[:user_id]
+        timestamp = attrs[:timestamp] || Time.new
+        context = attrs[:context] || {}
+        message_id = attrs[:message_id].to_s if attrs[:message_id]
+
+        check_presence! from, 'previous_id'
+        check_presence! to, 'user_id'
+        check_timestamp! timestamp
+        add_context context
+
+        enqueue({
+          :previousId => from,
+          :userId => to,
+          :integrations => attrs[:integrations],
+          :context => context,
+          :options => attrs[:options],
+          :messageId => message_id,
+          :timestamp => datetime_in_iso8601(timestamp),
+          :type => 'alias'
+        })
+      end
+
+      # Associates a user identity with a group.
+      #
+      # @see https://segment.com/docs/sources/server/ruby/#group
+      #
+      # @param [Hash] attrs
+      # @option attrs [String] :anonymous_id ID for a user when you don't know
+      #   who they are yet. (optional but you must provide either an
+      #   `anonymous_id` or `user_id`)
+      # @option attrs [Hash] :context ({})
+      # @option attrs [String] :group_id The ID of the group
+      # @option attrs [Hash] :integrations What integrations this event
+      #   goes to (optional)
+      # @option attrs [Hash] :options Options such as user traits (optional)
+      # @option attrs [Time] :timestamp When the event occurred (optional)
+      # @option attrs [String] :user_id The ID for the user that is part of
+      #   the group
+      # @option attrs [String] :message_id ID that uniquely identifies a
+      #   message across the API. (optional)
+      def group(attrs)
+        symbolize_keys! attrs
+        check_user_id! attrs
+
+        group_id = attrs[:group_id]
+        user_id = attrs[:user_id]
+        traits = attrs[:traits] || {}
+        timestamp = attrs[:timestamp] || Time.new
+        context = attrs[:context] || {}
+        message_id = attrs[:message_id].to_s if attrs[:message_id]
+
+        raise ArgumentError, '.traits must be a hash' unless traits.is_a? Hash
+        isoify_dates! traits
+
+        check_presence! group_id, 'group_id'
+        check_timestamp! timestamp
+        add_context context
+
+        enqueue({
+          :groupId => group_id,
+          :userId => user_id,
+          :traits => traits,
+          :integrations => attrs[:integrations],
+          :options => attrs[:options],
+          :context => context,
+          :messageId => message_id,
+          :timestamp => datetime_in_iso8601(timestamp),
+          :type => 'group'
+        })
+      end
+
+      # Records a page view
+      #
+      # @see https://segment.com/docs/sources/server/ruby/#page
+      #
+      # @param [Hash] attrs
+      # @option attrs [String] :anonymous_id ID for a user when you don't know
+      #   who they are yet. (optional but you must provide either an
+      #   `anonymous_id` or `user_id`)
+      # @option attrs [String] :category The page category (optional)
+      # @option attrs [Hash] :context ({})
+      # @option attrs [Hash] :integrations What integrations this event
+      #   goes to (optional)
+      # @option attrs [String] :name Name of the page
+      # @option attrs [Hash] :options Options such as user traits (optional)
+      # @option attrs [Hash] :properties Page properties (optional)
+      # @option attrs [Time] :timestamp When the pageview occurred (optional)
+      # @option attrs [String] :user_id The ID of the user viewing the page
+      # @option attrs [String] :message_id ID that uniquely identifies a
+      #   message across the API. (optional)
+      def page(attrs)
+        symbolize_keys! attrs
+        check_user_id! attrs
+
+        name = attrs[:name].to_s
+        properties = attrs[:properties] || {}
+        timestamp = attrs[:timestamp] || Time.new
+        context = attrs[:context] || {}
+        message_id = attrs[:message_id].to_s if attrs[:message_id]
+
+        raise ArgumentError, '.properties must be a hash' unless properties.is_a? Hash
+        isoify_dates! properties
+
+        check_timestamp! timestamp
+        add_context context
+
+        enqueue({
+          :userId => attrs[:user_id],
+          :anonymousId => attrs[:anonymous_id],
+          :name => name,
+          :category => attrs[:category],
+          :properties => properties,
+          :integrations => attrs[:integrations],
+          :options => attrs[:options],
+          :context => context,
+          :messageId => message_id,
+          :timestamp => datetime_in_iso8601(timestamp),
+          :type => 'page'
+        })
+      end
+
+      # Records a screen view (for a mobile app)
+      #
+      # @param [Hash] attrs
+      # @option attrs [String] :anonymous_id ID for a user when you don't know
+      #   who they are yet. (optional but you must provide either an
+      #   `anonymous_id` or `user_id`)
+      # @option attrs [String] :category The screen category (optional)
+      # @option attrs [Hash] :context ({})
+      # @option attrs [Hash] :integrations What integrations this event
+      #   goes to (optional)
+      # @option attrs [String] :name Name of the screen
+      # @option attrs [Hash] :options Options such as user traits (optional)
+      # @option attrs [Hash] :properties Page properties (optional)
+      # @option attrs [Time] :timestamp When the pageview occurred (optional)
+      # @option attrs [String] :user_id The ID of the user viewing the screen
+      # @option attrs [String] :message_id ID that uniquely identifies a
+      #   message across the API. (optional)
+      def screen(attrs)
+        symbolize_keys! attrs
+        check_user_id! attrs
+
+        name = attrs[:name].to_s
+        properties = attrs[:properties] || {}
+        timestamp = attrs[:timestamp] || Time.new
+        context = attrs[:context] || {}
+        message_id = attrs[:message_id].to_s if attrs[:message_id]
+
+        raise ArgumentError, '.properties must be a hash' unless properties.is_a? Hash
+        isoify_dates! properties
+
+        check_timestamp! timestamp
+        add_context context
+
+        enqueue({
+          :userId => attrs[:user_id],
+          :anonymousId => attrs[:anonymous_id],
+          :name => name,
+          :properties => properties,
+          :category => attrs[:category],
+          :options => attrs[:options],
+          :integrations => attrs[:integrations],
+          :context => context,
+          :messageId => message_id,
+          :timestamp => timestamp.iso8601,
+          :type => 'screen'
+        })
+      end
+
+      # @return [Fixnum] number of messages in the queue
+      def queued_messages
+        @queue.length
+      end
+
+      private
+
+      # private: Enqueues the action.
+      #
+      # returns Boolean of whether the item was added to the queue.
+      def enqueue(action)
+        # add our request id for tracing purposes
+        action[:messageId] ||= uid
+
+        if @queue.length < @max_queue_size
+          @queue << action
+          ensure_worker_running
+
+          true
+        else
+          logger.warn(
+            'Queue is full, dropping events. The :max_queue_size ' \
+            'configuration parameter can be increased to prevent this from ' \
+            'happening.'
+          )
+          false
+        end
+      end
+
+      # private: Ensures that a string is non-empty
+      #
+      # obj    - String|Number that must be non-blank
+      # name   - Name of the validated value
+      #
+      def check_presence!(obj, name)
+        if obj.nil? || (obj.is_a?(String) && obj.empty?)
+          raise ArgumentError, "#{name} must be given"
+        end
+      end
+
+      # private: Adds contextual information to the call
+      #
+      # context - Hash of call context
+      def add_context(context)
+        context[:library] = { :name => 'analytics-ruby', :version => Segment::Analytics::VERSION.to_s }
+      end
+
+      # private: Checks that the write_key is properly initialized
+      def check_write_key!
+        raise ArgumentError, 'Write key must be initialized' if @write_key.nil?
+      end
+
+      # private: Checks the timstamp option to make sure it is a Time.
+      def check_timestamp!(timestamp)
+        raise ArgumentError, 'Timestamp must be a Time' unless timestamp.is_a? Time
+      end
+
+      def event(attrs)
+        symbolize_keys! attrs
+
+        {
+          :userId => user_id,
+          :name => name,
+          :properties => properties,
+          :context => context,
+          :timestamp => datetime_in_iso8601(timestamp),
+          :type => 'screen'
+        }
+      end
+
+      def check_user_id!(attrs)
+        unless attrs[:user_id] || attrs[:anonymous_id]
+          raise ArgumentError, 'Must supply either user_id or anonymous_id'
+        end
+      end
+
+      def ensure_worker_running
+        return if worker_running?
+        @worker_mutex.synchronize do
+          return if worker_running?
+          @worker_thread = Thread.new do
+            @worker.run
+          end
+        end
+      end
+
+      def worker_running?
+        @worker_thread && @worker_thread.alive?
+      end
+    end
+  end
+end