sojourn 0.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 05e30ba3490b5cb18a66e3ecf4bdb0048e0ce529
+  data.tar.gz: 055a2accda2519d306ed020f9df334694cea68c0
+SHA512:
+  metadata.gz: 8c8eaa338c482230664097aae7910ebae14f9ebace498dc9feff819d96fce1b66e65546c1416f3e23e3dee6342c0936fe209e081eb11a1a0aeff62de82a74947
+  data.tar.gz: 70f60a8e7ba6a81055acd0306736b4feff026eed0f2dbac10d18510bd2e6e4dec6711a9c96eacac5eef6767ef12e1ce2b042d0739f31285ec95bdb9286f25f24

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sojourn.gemspec
+gemspec

data/README.md

@@ -0,0 +1,118 @@
+# Sojourn
+
+Simple source & event tracking for Rails. This gem automatically tracks *sojourners*
+(i.e. unique visitors) based on:
+
+* Referer
+* UTM parameters
+* Browser (User Agent)
+* The currently logged-in user (i.e. `current_user`)
+* Various other request data
+
+## How It Works
+
+**Everything is tracked in the form of events.** Yep, events all the way down.
+(See 'Why Events?' below for the reasoning behind this.)
+
+Sojourn assigns each *sojourner* a UUID, which is tracked across requests. All events are
+associated with this UUID and with the current user's ID (if logged-in).
+
+Events (`Sojourn::Event`) consist of a name, a set of properties (key-value hash) and information
+about the request. In the current ActiveRecord implementation, requests (`Sojourn::Request`) can
+be queried separately and may have many events. Requests also track browser (`Sojourn::Browser`)
+and campaign (`Sojourn::Campaign`) info as unique models. See 'Usage' below for the details
+of these models.
+
+
+## Usage
+
+```ruby
+# Track a custom event (highly encouraged!):
+sojourn.track! 'clicked call-to-action', plan_choice: 'enterprise'
+
+e = Sojourn::Event.last
+e.name               # event name (e.g. 'clicked call-to-action')
+e.sojourner_uuid     # uuid tracked across requests, stored in cookie
+e.user               # User or nil
+e.properties         # key-value hash (e.g. "{ plan_choice: 'enterprise' }")
+e.request            # Sojourn::Request object
+
+r = Sojourn::Request.last
+r.referer
+r.host
+r.path
+r.controller
+r.action
+r.params
+r.method
+r.ip_address
+r.campaign           # Sojourn::Campaign object (nil if no campaign detected)
+r.browser            # Sojourn::Browser object
+
+b = Sojourn::Browser.last
+b.known?             # whether or not the browser was detected successfully
+b.user_agent
+b.name
+b.version
+b.platform
+b.bot?
+
+c = Sojourn::Campaign.last
+c.path               # Base path (e.g. '/posts/2')
+c.params             # Notable (tracked) params, sorted. (Typically utm-style, but configurable.)
+
+```
+
+## Default Events
+
+The three built-in events are as follows:
+
+```ruby
+'!sojourning' # The sojourner has arrived from an external source.
+'!logged_in'  # The sojourner has logged-in.
+'!logged_out' # The sojourner has logged-out.
+```
+
+A `'!sojourning'` event takes place whenever any of the following is true:
+
+* The sojourner has never been seen before (i.e. direct traffic of some kind)
+* The referer is from an external source (i.e. not the current `request.host`)
+* The request contains tracked (utm-style) parameters. (These can be configured in the `sojourn.rb`
+  initializer.)
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sojourn'
+```
+
+And then execute:
+
+    $ bundle
+
+To install migrations and the `sojourn.rb` initializer, execute:
+
+    $ rails g sojourn:install
+
+## Why Events? Why not track visits/visitors as their own objects?
+
+The idea is that, at a certain scale, this kind of tracking should be dumped directly into
+append-only logs (or an event bus / messaging queue) for asynchronous processing.
+
+This is made easier when everything can be represented, at a basic level, as discrete events.
+In theory, it works with just about any data store, and makes for easy time series and funnel
+analysis. I'd like to move away from ActiveRecord at some point and open up the door for other,
+highly scalable data backends.
+
+## Current Limitations (i.e. the 'todo' list)
+
+* Tested only on rails 3.2.18 and ruby 2.0.0 with ActiveRecord and PostgreSQL.
+* Assumes `User` and `current_user` convention for user tracking.
+* Assumes that if `request.referer` does not match `request.host`, the referer is external to your
+  website.
+* Relies solely on cookies to track visitor UUID across requests (no JS, fingerprinting, etc)
+* Relies on ActiveRecord for storage. (At a bigger scale, append-only logs are preferred)
+* There are no tests.

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/generators/sojourn/install_generator.rb

@@ -0,0 +1,35 @@
+require 'rails/generators/active_record'
+module Sojourn
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      desc 'Copies sojourn migrations to your file.'
+      source_root File.expand_path('../templates', __FILE__)
+
+      def self.next_migration_number(dirname)
+        next_migration_number = current_migration_number(dirname) + 1
+        if ::ActiveRecord::Base.timestamped_migrations
+          [Time.now.utc.strftime('%Y%m%d%H%M%S'), format('%.14d', next_migration_number)].max
+        else
+          format('%.3d', next_migration_number)
+        end
+      end
+
+      def create_config_file
+        template 'config_initializer.rb', 'config/initializers/sojourn.rb'
+      end
+
+      def create_migrations
+        %w(campaigns browsers requests events).map { |m| "create_sojourn_#{m}" }.each do |name|
+          if self.class.migration_exists?('db/migrate', name)
+            say "        #{set_color('skip', :yellow)}  #{name}.rb (migration already exists)"
+          else
+            migration_template "#{name}.rb", "db/migrate/#{name}.rb"
+            sleep 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/generators/sojourn/templates/config_initializer.rb

@@ -0,0 +1,37 @@
+Sojourn.configure do |config|
+
+  # A new '!sojourning' event is created whenever:
+  #    1. The 'referer' is external
+  #    2. There are utm-style parameters in the request.
+  #    3. The visitor is new and has never been assigned a 'sojourner_id' (i.e. direct traffic)
+  # The two events '!logged_in' and '!logged_out' are created whenever sojourn detects a
+  # change to `current_user`.
+
+  # To disable all automatic event tracking, uncomment the following line:
+  # config.tracking_enabled = false
+
+  # You may customize the list of tracked (utm-style) parameters here.
+  # Note: Using tracked params on internal links within your site is NOT recommended, as this will
+  #       result in many repeated '!sojourning' events. Instead, you should use a different set
+  #       of parameters (such as 'from', 'source', or 'referer') and NOT include them here.
+  # Default: [:utm_source, :utm_medium, :utm_term, :utm_content, :utm_campaign]
+  #
+  # config.campaign_params += [:my_custom_tracking_param]
+
+  # By default, sojourn will attach `user_id`, `sojourner_uuid`, and a `created_at` timestamp
+  # to every event. If you would like to add additional properties, you may do so as follows.
+  # Note: This block will be called in the context of your controller.
+  #
+  # config.default_properties do |p|
+  #   p[:rails_env] = Rails.env
+  #   p[:my_custom_property] = method_defined_in_controller
+  # end
+
+  # By default, sojourn uses a signed, permanent cookie to store the sojourner uuid. You
+  # may specifiy an alternate/custom session_store, or change the name of the cookie that
+  # gets created. (default is `:_sojourn`)
+  #
+  # config.session_store = Sojourn::SessionStores::Cookie
+  # config.cookie_name = :my_custom_cookie_name
+
+end

data/lib/generators/sojourn/templates/create_sojourn_browsers.rb

@@ -0,0 +1,13 @@
+class CreateSojournBrowsers < ActiveRecord::Migration
+  def change
+    create_table :sojourn_browsers do |t|
+      t.text :user_agent, unique: true
+      t.string :name
+      t.string :version
+      t.string :platform
+      t.boolean :known
+      t.boolean :bot
+    end
+    add_index :sojourn_browsers, [:user_agent]
+  end
+end

data/lib/generators/sojourn/templates/create_sojourn_campaigns.rb

@@ -0,0 +1,10 @@
+class CreateSojournCampaigns < ActiveRecord::Migration
+  def change
+    create_table :sojourn_campaigns do |t|
+      t.string :path, limit: 2048
+      t.string :params, limit: 2048
+      t.timestamp :created_at
+    end
+    add_index :sojourn_campaigns, [:path, :params]
+  end
+end

data/lib/generators/sojourn/templates/create_sojourn_events.rb

@@ -0,0 +1,17 @@
+class CreateSojournEvents < ActiveRecord::Migration
+  def change
+    create_table :sojourn_events do |t|
+      t.string :sojourner_uuid, limit: 36, null: false
+      t.string :name
+      t.text :properties
+      t.references :sojourn_request
+      t.references :user
+      t.timestamp :created_at
+    end
+    add_index :sojourn_events, [:sojourner_uuid]
+    add_index :sojourn_events, [:sojourn_request_id]
+    add_index :sojourn_events, [:user_id]
+    add_index :sojourn_events, [:created_at]
+    add_index :sojourn_events, [:name]
+  end
+end

data/lib/generators/sojourn/templates/create_sojourn_requests.rb

@@ -0,0 +1,19 @@
+class CreateSojournRequests < ActiveRecord::Migration
+  def change
+    create_table :sojourn_requests do |t|
+      t.references :sojourn_campaign
+      t.references :sojourn_browser
+      t.string :host, limit: 2048
+      t.string :path, limit: 2048
+      t.string :method
+      t.string :controller
+      t.string :action
+      t.string :ip_address
+      t.text :params
+      t.text :referer
+      t.timestamp :created_at
+    end
+    add_index :sojourn_requests, [:sojourn_campaign_id]
+    add_index :sojourn_requests, [:sojourn_browser_id]
+  end
+end

data/lib/sojourn.rb

@@ -0,0 +1,24 @@
+require_relative 'sojourn/version'
+require_relative 'sojourn/configuration'
+require_relative 'sojourn/controller'
+
+module Sojourn
+  def self.table_name_prefix
+    'sojourn_'
+  end
+
+  def self.configure(&block)
+    block.call(config)
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.tables_exist?
+    @tables_exist ||= %w(sojourn_events sojourn_requests sojourn_browsers sojourn_campaigns)
+                      .map { |t| ActiveRecord::Base.connection.table_exists?(t) }.all?
+  end
+end
+
+ActionController::Base.send :include, Sojourn::Controller

data/lib/sojourn/browser.rb

@@ -0,0 +1,27 @@
+require 'browser'
+
+module Sojourn
+  class Browser < ActiveRecord::Base
+    has_many :requests, foreign_key: :sojourn_browser_id
+    has_many :events, through: :requests
+
+    def self.from_request(request)
+      where(user_agent: request.user_agent).first_or_initialize
+    end
+
+    before_validation do
+      self.name ||= browser.name
+      self.version ||= browser.version
+      self.platform ||= browser.platform
+      self.known ||= browser.known?
+      self.bot ||= browser.bot?
+      true # otherwise .valid? will return false
+    end
+
+  private
+
+    def browser
+      @browser ||= ::Browser.new(user_agent: user_agent)
+    end
+  end
+end

data/lib/sojourn/campaign.rb

@@ -0,0 +1,27 @@
+module Sojourn
+  class Campaign < ActiveRecord::Base
+
+    has_many :requests, foreign_key: :sojourn_campaign_id
+    has_many :events, through: :requests
+
+    class << self
+
+      def from_request(request)
+        return unless (params = tracked_params(request.params)).any?
+        where(path: request.path.downcase.try(:truncate, 2048))
+          .where(params: params.to_param.try(:truncate, 2048)).first_or_initialize
+      end
+
+    private
+
+      def tracked_params(params)
+        Hash[filter_params(params).sort.map { |k, v| [k.downcase, v.downcase] }]
+      end
+
+      def filter_params(params)
+        params.slice(*Sojourn.config.campaign_params).delete_if { |_, v| v.blank? }
+      end
+
+    end
+  end
+end

data/lib/sojourn/configuration.rb

@@ -0,0 +1,28 @@
+require_relative 'session_stores/cookie'
+
+class Configuration
+
+  attr_accessor :campaign_params
+  attr_accessor :session_store
+  attr_accessor :cookie_name
+  attr_accessor :tracking_enabled
+  attr_accessor :default_properties_block
+
+  def initialize
+    set_defaults
+  end
+
+  def default_properties(&block)
+    self.default_properties_block = block
+  end
+
+private
+
+  def set_defaults
+    self.campaign_params = [:utm_source, :utm_medium, :utm_term, :utm_content, :utm_campaign]
+    self.session_store = Sojourn::SessionStores::Cookie
+    self.cookie_name = :_sojourn
+    self.tracking_enabled = true
+  end
+
+end

data/lib/sojourn/controller.rb

@@ -0,0 +1,26 @@
+require_relative 'tracker'
+
+module Sojourn
+  module Controller
+
+    def self.included(base)
+      base.before_filter :track_sojourning
+      base.before_filter :save_sojourn_session
+    end
+
+    def sojourn
+      @sojourn ||= Tracker.new(self)
+    end
+
+  private
+
+    def track_sojourning
+      sojourn.sojourning!
+    end
+
+    def save_sojourn_session
+      sojourn.update_session!
+    end
+
+  end
+end

data/lib/sojourn/event.rb

@@ -0,0 +1,22 @@
+module Sojourn
+  class Event < ActiveRecord::Base
+    DEFAULT_FIELDS = [:id, :sojourner_uuid, :name, :properties, :sojourn_request_id, :user_id, :created_at]
+
+    belongs_to :request, foreign_key: :sojourn_request_id
+    belongs_to :user
+    has_one :campaign, through: :request
+    has_one :browser, through: :request
+
+    serialize :properties
+
+    before_save do
+      properties.keys.map(&:to_sym).each do |key|
+        send("#{key}=", properties[key]) if self.class.available_fields.include?(key)
+      end
+    end
+
+    def self.available_fields
+      @available_fields ||= column_names.map(&:to_sym) - DEFAULT_FIELDS
+    end
+  end
+end

data/lib/sojourn/request.rb

@@ -0,0 +1,42 @@
+require_relative 'campaign'
+require_relative 'browser'
+require_relative 'serializers/symbol'
+require 'addressable/uri'
+
+module Sojourn
+  class Request < ActiveRecord::Base
+    attr_accessor :user_agent
+
+    serialize :method, Serializers::Symbol
+    serialize :params
+
+    belongs_to :campaign, foreign_key: :sojourn_campaign_id
+    belongs_to :browser, foreign_key: :sojourn_browser_id
+    has_many :events, foreign_key: :sojourn_request_id
+
+    def self.from_request(request)
+      new referer: request.referer.try(:truncate, 2048),
+          host: request.host.try(:truncate, 2048),
+          path: request.path.try(:truncate, 2048),
+          controller: request.params[:controller],
+          action: request.params[:action],
+          params: request.filtered_parameters.with_indifferent_access.except(:controller, :action),
+          method: request.request_method_symbol,
+          ip_address: request.remote_ip,
+          user_agent: request.user_agent
+    end
+
+    before_validation do
+      self.campaign ||= Campaign.from_request(self)
+      self.browser ||= Browser.from_request(self) if user_agent
+    end
+
+    def outside_referer?
+      referer.present? && Addressable::URI.parse(referer).host != host
+    end
+
+    def any_utm_data?
+      Sojourn.config.campaign_params.map { |p| params[p].present? }.any?
+    end
+  end
+end

data/lib/sojourn/serializers/symbol.rb

@@ -0,0 +1,13 @@
+module Sojourn
+  module Serializers
+    class Symbol
+      def self.load(string)
+        string.to_sym
+      end
+
+      def self.dump(symbol)
+        symbol.to_s
+      end
+    end
+  end
+end

data/lib/sojourn/session_stores/cookie.rb

@@ -0,0 +1,49 @@
+module Sojourn
+  module SessionStores
+    class Cookie
+
+      def initialize(ctx)
+        @ctx = ctx
+      end
+
+      def sojourner_uuid
+        cookie_data[:uuid]
+      end
+
+      def sojourner_uuid=(value)
+        cookies.permanent.signed[cookie_name] = { value: cookie_data.merge(uuid: value) }
+      end
+
+      def sojourner_tracked?
+        cookie_data.key?(:uuid)
+      end
+
+      def user_id
+        cookie_data[:user_id]
+      end
+
+      def user_id=(value)
+        cookies.permanent.signed[cookie_name] = { value: cookie_data.merge(user_id: value) }
+      end
+
+      def user_tracked?
+        cookie_data.key?(:user_id)
+      end
+
+    private
+
+      def cookie_data
+        cookies.signed[cookie_name] || {}
+      end
+
+      def cookies
+        @ctx.send(:cookies)
+      end
+
+      def cookie_name
+        @cookie_name ||= Sojourn.config.cookie_name
+      end
+
+    end
+  end
+end

data/lib/sojourn/tracker.rb

@@ -0,0 +1,76 @@
+require_relative 'request'
+require_relative 'event'
+
+module Sojourn
+  class Tracker
+    attr_accessor :ctx
+    delegate :current_user, to: :ctx
+
+    def initialize(ctx)
+      self.ctx = ctx
+    end
+
+    def track!(event_name, properties = {}, user_id = current_user_id)
+      return unless Sojourn.tables_exist?
+      properties = default_event_properties.merge(properties)
+      Event.create! sojourner_uuid: sojourner_uuid, name: event_name, request: request,
+                    properties: properties, user_id: user_id
+    end
+
+    def sojourning!
+      return unless Sojourn.config.tracking_enabled && Sojourn.tables_exist?
+      track!('!sojourning') if sojourning?
+      track_user_change! if user_changed?
+    end
+
+    def track_user_change!
+      return unless user_changed?
+      track!('!logged_out', {}, session.user_id) if session.user_id
+      track!('!logged_in', {}, current_user_id) if current_user_id
+    end
+
+    def update_session!
+      session.sojourner_uuid ||= sojourner_uuid
+      session.user_id = current_user_id
+    end
+
+  private
+
+    def request
+      @request ||= Request.from_request(ctx.request)
+    end
+
+    def session
+      @session ||= Sojourn.config.session_store.new(ctx)
+    end
+
+    def sojourner_uuid
+      @sojourner_uuid ||= session.sojourner_uuid || SecureRandom.uuid
+    end
+
+    def sojourning?
+      request.outside_referer? || request.any_utm_data? || !session.sojourner_tracked?
+    end
+
+    def user_changed?
+      session.user_tracked? && session.user_id != current_user_id
+    end
+
+    def current_user_id
+      current_user.try(:id)
+    end
+
+    def default_event_properties
+      @default_event_properties ||= fetch_default_properties
+    end
+
+    def fetch_default_properties(properties = {})
+      if Sojourn.config.default_properties_block
+        @ctx.define_singleton_method :sojourn_event_properties,
+                                     Sojourn.config.default_properties_block
+      end
+      @ctx.sojourn_event_properties(properties) if @ctx.respond_to? :sojourn_event_properties
+      properties
+    end
+  end
+end

data/lib/sojourn/version.rb

@@ -0,0 +1,3 @@
+module Sojourn
+  VERSION = '0.0.7'
+end

data/sojourn.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sojourn/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'sojourn'
+  spec.version       = Sojourn::VERSION
+  spec.authors       = ['Smudge']
+  spec.email         = ['nathan@ngriffith.com']
+  spec.summary       = 'Simple user source tracking for Rails.'
+  spec.description   = %(
+Sojourn tracks site visitors and sources, with the ability to recognise
+multiple sources per visitor. Each time a new source is detected,
+sojourn tracks the referer, utm data, and logged-in user (if any)).gsub("\n", ' ')
+  spec.homepage      = ''
+  spec.license       = ''
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(/^bin/) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)/)
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+
+  spec.add_dependency 'browser', '>= 0.8.0'
+  spec.add_dependency 'addressable', '>= 2.3.1'
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: sojourn
+version: !ruby/object:Gem::Version
+  version: 0.0.7
+platform: ruby
+authors:
+- Smudge
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: browser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.1
+description: " Sojourn tracks site visitors and sources, with the ability to recognise
+  multiple sources per visitor. Each time a new source is detected, sojourn tracks
+  the referer, utm data, and logged-in user (if any)"
+email:
+- nathan@ngriffith.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- lib/generators/sojourn/install_generator.rb
+- lib/generators/sojourn/templates/config_initializer.rb
+- lib/generators/sojourn/templates/create_sojourn_browsers.rb
+- lib/generators/sojourn/templates/create_sojourn_campaigns.rb
+- lib/generators/sojourn/templates/create_sojourn_events.rb
+- lib/generators/sojourn/templates/create_sojourn_requests.rb
+- lib/sojourn.rb
+- lib/sojourn/browser.rb
+- lib/sojourn/campaign.rb
+- lib/sojourn/configuration.rb
+- lib/sojourn/controller.rb
+- lib/sojourn/event.rb
+- lib/sojourn/request.rb
+- lib/sojourn/serializers/symbol.rb
+- lib/sojourn/session_stores/cookie.rb
+- lib/sojourn/tracker.rb
+- lib/sojourn/version.rb
+- sojourn.gemspec
+homepage: ''
+licenses:
+- ''
+metadata: {}
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Simple user source tracking for Rails.
+test_files: []
+has_rdoc: