mongoid_traffic 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf4d620d49237e71867b64bd7a22a4c8f9aeb58a
-  data.tar.gz: 37472e818324e9b2a2ac98806468a66468645545
+  metadata.gz: 260b37762762b8a339f5d105b27669f02f334aa7
+  data.tar.gz: 1d88427a3c295874d9919c6e82c2c2dbbf63db9e
 SHA512:
-  metadata.gz: 1bd178089d1d2471e02796b85cf055f2b9c99ede31b2d78ef489065561f2b2be43e0631383df724b7fab8aa5b52c2c1495d31ba06c6354de34e8f61e0a4f30e9
-  data.tar.gz: b75bad4a25337c6191cf4403016e9051c05a61522456f92a79af417c6f1b856da4042e494f040fff5f8f56bccb576a8945490c749ea8834894f7f195731bd82a
+  metadata.gz: 6529fe616f86a44d7b2d52b5e7cea49ff117408b9e8ad013f46cecfcad4f042a7b9fa202c60fdef8222b0ff66addd75afa021e05d5fb17a51d4f9b382383ca4a
+  data.tar.gz: 484d9a993fe2e1c11cc89ddb077f84c7935f03dbd861a024f63ab4f72179171e99297c6e681cc87ca02cf224d497baa4afb15e49508150021b9ac32b7a1c78a7

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# CHANGELOG
+
+## 0.1.0
+
+* BREAKING: Logs stored in custom class
+
+## 0.0.2
+
+* Initial release

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mongoid_traffic (0.0.2)
+    mongoid_traffic (0.1.0)
       geoip
       mongoid (~> 4.0)
       nokogiri
@@ -10,21 +10,21 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (4.1.4)
-      activesupport (= 4.1.4)
+    activemodel (4.2.0)
+      activesupport (= 4.2.0)
       builder (~> 3.1)
-    activesupport (4.1.4)
-      i18n (~> 0.6, >= 0.6.9)
+    activesupport (4.2.0)
+      i18n (~> 0.7)
       json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
-      thread_safe (~> 0.1)
+      thread_safe (~> 0.3, >= 0.3.4)
       tzinfo (~> 1.1)
     bson (2.3.0)
     builder (3.2.2)
     celluloid (0.15.2)
       timers (~> 1.1.0)
     coderay (1.1.0)
-    connection_pool (2.0.0)
+    connection_pool (2.1.0)
     coveralls (0.7.0)
       multi_json (~> 1.3)
       rest-client
@@ -45,7 +45,7 @@ GEM
     guard-minitest (2.3.1)
       guard (~> 2.0)
       minitest (>= 3.0)
-    i18n (0.6.11)
+    i18n (0.7.0)
     json (1.8.1)
     listen (2.7.9)
       celluloid (>= 0.15.2)
@@ -54,21 +54,21 @@ GEM
     lumberjack (1.0.9)
     method_source (0.8.2)
     mime-types (1.25.1)
-    mini_portile (0.6.0)
+    mini_portile (0.6.1)
     minitest (5.4.0)
     mongoid (4.0.0)
       activemodel (~> 4.0)
       moped (~> 2.0.0)
       origin (~> 2.1)
       tzinfo (>= 0.3.37)
-    moped (2.0.0)
+    moped (2.0.2)
       bson (~> 2.2)
       connection_pool (~> 2.0)
       optionable (~> 0.2.0)
     multi_json (1.10.1)
     netrc (0.7.7)
-    nokogiri (1.6.3.1)
-      mini_portile (= 0.6.0)
+    nokogiri (1.6.5)
+      mini_portile (~> 0.6.0)
     optionable (0.2.0)
     origin (2.1.1)
     pry (0.10.0)

data/README.md

@@ -8,7 +8,7 @@ Aggregated traffic logs stored in MongoDB. Fast and efficient logging via atomic
 
 Add this line to your application's Gemfile:
 
-```Ruby
+```ruby
 gem 'mongoid_traffic'
 ```
 
@@ -26,13 +26,28 @@ $ gem install mongoid_traffic
 
 ## Usage
 
+Setup your class for storing the log:
+
+```ruby
+class MyLog
+	include Mongoid::Document
+	include MongoidTraffic::Log
+end
+```
+
 Log your traffic like this:
 
-```Ruby
-MongoidTraffic::Logger.log
+```ruby
+MongoidTraffic::Logger.log(MyLog, *args)
 ```
 
-This will (by default) create two `MongoidTraffic::Log` documents: first with `:df(date_from)` and `:dt(date_to)` fields specifying monthly log, second with dates specifying daily log. Each log has an `:access_count` attribute that is incremented with subsequent `.log` calls.
+Or, if you prefer, directly on the `MyLog` class:
+
+```ruby
+MyLog.log(*args)
+```
+
+This will (by default) create two `MyLog` documents: first with `:df(date_from)` and `:dt(date_to)` fields specifying monthly log, second with dates specifying daily log. Each log has an `:access_count` attribute that is incremented with subsequent `.log` calls.
 
 ### Optional arguments
 
@@ -40,29 +55,29 @@ This will (by default) create two `MongoidTraffic::Log` documents: first with `:
 
 By default, the `.log` method creates/updates a document with aggregations for month and a document with aggregations for a day. You can however customize this behaviour like this:
 
-```Ruby
-MongoidTraffic::Logger.log(time_scope: %i(month week day))
+```ruby
+MyLog.log(time_scope: %i(month week day))
 ```
 
 The available options are: `%(year month week day)`
 
 #### Scope:
 
-```Ruby
-MongoidTraffic::Logger.log(scope: '/pages/123')
+```ruby
+MyLog.log(scope: '/pages/123')
 ```
 
 Allows to create several logs for different scopes of your application (typically URLs).
 
 #### User-Agent:
 
-```Ruby
-MongoidTraffic::Logger.log(user_agent: user_agent_string)
+```ruby
+MyLog.log(user_agent: user_agent_string)
 ```
 
 Logs platform-browser-version access count:
 
-```Ruby
+```ruby
 { "Macintosh" => { "Safari" => { "8%2E0" => 1, "7%2E1" => 2 } } }
 ```
 
@@ -70,13 +85,13 @@ Please note the keys are escaped. You might want to unescape them using for exam
 
 #### Referer:
 
-```Ruby
-MongoidTraffic::Logger.log(referer: http_referer_string)
+```ruby
+MyLog.log(referer: http_referer_string)
 ```
 
 Logs referer access count:
 
-```Ruby
+```ruby
 { "http%3A%2F%2Fwww%2Egoogle%2Ecom" => 1 }
 ```
 
@@ -86,29 +101,29 @@ If the referer is included in the [bot list](http://www.user-agents.org/allagent
 
 #### Country (via IP address):
 
-```Ruby
-MongoidTraffic::Logger.log(ip_address: '123.123.123.123')
+```ruby
+MyLog.log(ip_address: '123.123.123.123')
 ```
 
 Logs access count by country code 2:
 
-```Ruby
+```ruby
 { "CZ" => 100, "DE" => 1 }
 ```
 
 Uses the [GeoIP](https://github.com/cjheath/geoip) library to infer country_code from IP address.
 
-You might can use for example the [countries gem](https://github.com/hexorx/countries) to convert the country code to country name etc.
+You can use the [countries gem](https://github.com/hexorx/countries) to convert the country code to country name etc.
 
 #### Unique id:
 
-```Ruby
-MongoidTraffic::Logger.log(unique_id: unique_id_string)
+```ruby
+MyLog.log(unique_id: unique_id_string)
 ```
 
 Logs access count by id:
 
-```Ruby
+```ruby
 { "0123456789" => 100, "ABCDEFGHIJ" => 1 }
 ```
 
@@ -118,9 +133,9 @@ Typically you would pass it something like `session_id` to track unique visitors
 
 In case of Rails, you can use the `.after_action` macro with the `#log_traffic` helper method in your controllers:
 
-```Ruby
+```ruby
 class MyController < ApplicationController
-	after_action :log_traffic, only: [:show]
+	after_action -> { log_traffic(MyLog) }, only: [:show]
 end
 ```
 
@@ -128,32 +143,26 @@ The method automatically infers most of the options from the controller `request
 
 Additionally the `:log_scoped_traffic` method adds a scope by the current request path (`/pages/123`):
 
-```Ruby
+```ruby
 class MyController < ApplicationController
-	after_action :log_scoped_traffic, only: [:show]
+	after_action -> { log_scoped_traffic(MyLog) }, only: [:show]
 end
 ```
 
 You can override this behavior with custom scope like this:
 
-```Ruby
+```ruby
 class MyController < ApplicationController
-	after_action :log_scoped_traffic, only: [:show]
-
-	private
-	
-	def log_scoped_traffic
-		super scope: 'my-scope-comes-here'
-	end
+	after_action -> { log_scoped_traffic(MyLog, scope: 'my-scope-comes-here') }, only: [:show]
 end
 ```
 
 It might be good idea to use both methods in order to log access to the whole site as well as access to individual pages:
 
-```Ruby
+```ruby
 class MyController < ApplicationController
-	after_action :log_traffic, only: [:show]
-	after_action :log_scoped_traffic, only: [:show]
+	after_action -> { log_traffic(MyLog) }, only: [:show]
+	after_action -> { log_scoped_traffic(MyLog) }, only: [:show]
 end
 ```
 
@@ -194,26 +203,26 @@ Lastly, to retrieve the number of unique visits:
 
 Typically you first query by time:
 
-```Ruby
-Mongoid::TrafficLog.daily(Date.today)
+```ruby
+MyLog.daily(Date.today)
 ```
 
 And eventually by scope:
 
-```Ruby
-Mongoid::TrafficLog.daily(Date.today).scoped_to('/pages/123')
+```ruby
+MyLog.daily(Date.today).scoped_to('/pages/123')
 ```
 
 Followed by an aggregation. For example on access count:
 
-```Ruby
-Mongoid::TrafficLog.daily(Date.today).scoped_to('/pages/123').aggregate_on(:access_count)
+```ruby
+MyLog.daily(Date.today).scoped_to('/pages/123').aggregate_on(:access_count)
 ```
 
 The scope query accepts regular expressions, which allows for aggregations on specific parts of your site. For example should you want to query for all pages that have path beginning with '/blog':
 
-```Ruby
-Mongoid::TrafficLog.monthly(8, 2014).scoped_to(/\A\/blog/).aggregate_on(:countries)
+```ruby
+MyLog.monthly(8, 2014).scoped_to(/\A\/blog/).aggregate_on(:countries)
 ```
 
 ## TODO

data/lib/mongoid_traffic/controller_additions.rb

@@ -1,8 +1,9 @@
 module MongoidTraffic
   module ControllerAdditions
 
-    def log_traffic scope: nil
+    def log_traffic log_cls, scope: nil
       MongoidTraffic::Logger.log(
+        log_cls,
         ip_address: request.remote_ip,
         referer: request.headers['Referer'],
         unique_id: request.session_options[:id], # FIXME: not sure about this
@@ -10,7 +11,7 @@ module MongoidTraffic
       )
     end
     
-    def log_scoped_traffic scope: nil
+    def log_scoped_traffic log_cls, scope: nil
       log_traffic(scope: (scope || request.fullpath.split('?').first))
     end
 

data/lib/mongoid_traffic/log.rb

@@ -1,86 +1,93 @@
+require 'logger'
+
 module MongoidTraffic
-  class Log
+  module Log
 
-    include Mongoid::Document
+    def self.included base
+      base.extend ClassMethods
+      base.class_eval do
+        field :s, as: :scope, type: String
 
-    # ---------------------------------------------------------------------
-    
-    field :s, as: :scope, type: String
+        field :ac, as: :access_count, type: Integer
 
-    field :ac, as: :access_count, type: Integer
+        field :b, as: :browsers, type: Hash, default: {}
+        field :c, as: :countries, type: Hash, default: {}
+        field :r, as: :referers, type: Hash, default: {}
+        field :u, as: :unique_ids, type: Hash, default: {}
 
-    field :b, as: :browsers, type: Hash, default: {}
-    field :c, as: :countries, type: Hash, default: {}
-    field :r, as: :referers, type: Hash, default: {}
-    field :u, as: :unique_ids, type: Hash, default: {}
+        field :uat, as: :updated_at, type: Time
 
-    field :uat, as: :updated_at, type: Time
+        # ---------------------------------------------------------------------
 
-    # ---------------------------------------------------------------------
-    
-    field :df, as: :date_from, type: Date
-    field :dt, as: :date_to, type: Date
+        field :df, as: :date_from, type: Date
+        field :dt, as: :date_to, type: Date
 
-    # ---------------------------------------------------------------------
-    
-    validates :date_from, presence: true
-    validates :date_to, presence: true
+        # ---------------------------------------------------------------------
 
-    # ---------------------------------------------------------------------
-    
-    default_scope -> { where(scope: nil) }
+        validates :date_from, presence: true
+        validates :date_to, presence: true
 
-    scope :for_dates, -> date_from, date_to { where(date_from: date_from, date_to: date_to) }
+        # ---------------------------------------------------------------------
 
-    scope :yearly, -> year { self.for_dates(Date.parse("01/01/#{year}"), Date.parse("01/01/#{year}").at_end_of_year) }
-    scope :monthly, -> month, year { self.for_dates(Date.parse("01/#{month}/#{year}"), Date.parse("01/#{month}/#{year}").at_end_of_month) }
-    scope :weekly, -> week, year { self.for_dates(Date.commercial(year, week), Date.commercial(year, week).at_end_of_week) }
-    scope :daily, -> date { self.for_dates(date, date) }
+        default_scope -> { where(scope: nil) }
 
-    scope :scoped_to, -> scope { where(scope: scope) }
-    
-    # ---------------------------------------------------------------------
-    
-    index({ scope: 1, date_from: 1, date_to: 1 })
+        scope :for_dates, -> date_from, date_to { where(date_from: date_from, date_to: date_to) }
 
-    # =====================================================================
-    
-    def self.aggregate_on att
-      case find_field_by_name(att).type.to_s
-      when 'Integer' then sum(att)
-      when 'Hash' then sum_hash(att)
+        scope :yearly, -> year { self.for_dates(Date.parse("01/01/#{year}"), Date.parse("01/01/#{year}").at_end_of_year) }
+        scope :monthly, -> month, year { self.for_dates(Date.parse("01/#{month}/#{year}"), Date.parse("01/#{month}/#{year}").at_end_of_month) }
+        scope :weekly, -> week, year { self.for_dates(Date.commercial(year, week), Date.commercial(year, week).at_end_of_week) }
+        scope :daily, -> date { self.for_dates(date, date) }
+
+        scope :scoped_to, -> scope { where(scope: scope) }
+
+        # ---------------------------------------------------------------------
+
+        index({ scope: 1, date_from: 1, date_to: 1 })
       end
     end
 
-    def self.sum att
-      if att.to_sym == :unique_ids
-        aggregate_on(:unique_ids).keys.count
-      else
-        super(att)
+    # =====================================================================
+
+    module ClassMethods
+      def log *args
+        MongoidTraffic::Logger.log(self, *args)
       end
-    end
 
-    private # =============================================================
-    
-    def self.find_field_by_name field_name
-      return unless f = fields.detect{ |k,v| k == field_name.to_s or v.options[:as].to_s == field_name.to_s }
-      f.last
-    end
+      def aggregate_on att
+        case find_field_by_name(att).type.to_s
+        when 'Integer' then sum(att)
+        when 'Hash' then sum_hash(att)
+        end
+      end
+
+      def sum att
+        if att.to_sym == :unique_ids
+          aggregate_on(:unique_ids).keys.count
+        else
+          super(att)
+        end
+      end
+
+      def find_field_by_name field_name
+        return unless f = fields.detect{ |k,v| k == field_name.to_s or v.options[:as].to_s == field_name.to_s }
+        f.last
+      end
 
-    def self.sum_hash field_name
-      self.pluck(field_name).inject({}) do |res, h|
-        merger = proc { |key, v1, v2| 
-          if Hash === v1 && Hash === v2
-            v1.merge(v2, &merger)
-          elsif Hash === v2
-            v2
-          else
-            v1.to_i + v2.to_i
-          end
-        }
-        res = res.merge(h, &merger)
+      def sum_hash field_name
+        self.pluck(field_name).inject({}) do |res, h|
+          merger = proc { |key, v1, v2|
+            if Hash === v1 && Hash === v2
+              v1.merge(v2, &merger)
+            elsif Hash === v2
+              v2
+            else
+              v1.to_i + v2.to_i
+            end
+          }
+          res = res.merge(h, &merger)
+        end
       end
     end
 
   end
-end
+end

data/lib/mongoid_traffic/logger.rb

@@ -14,13 +14,14 @@ module MongoidTraffic
 
     # ---------------------------------------------------------------------
     
-    def self.log *args
-      new(*args).log
+    def self.log log_cls, *args
+      new(log_cls, *args).log
     end
 
     # ---------------------------------------------------------------------
 
-    def initialize ip_address: nil, referer: nil, scope: nil, time_scope: %i(month day), unique_id: nil, user_agent: nil 
+    def initialize log_cls, ip_address: nil, referer: nil, scope: nil, time_scope: %i(month day), unique_id: nil, user_agent: nil 
+      @log_cls = log_cls
       @ip_address = ip_address
       @referer_string = referer
       @scope = scope
@@ -34,7 +35,7 @@ module MongoidTraffic
       raise "Invalid time scope definition: #{@time_scope}" unless @time_scope.all?{ |ts| TIME_SCOPE_OPTIONS.include?(ts) }
 
       @time_scope.each do |ts|
-        Log.collection.find( find_query(ts) ).upsert( upsert_query )
+        @log_cls.collection.find( find_query(ts) ).upsert( upsert_query )
       end
     end
 

data/lib/mongoid_traffic/version.rb

@@ -1,3 +1,3 @@
 module MongoidTraffic
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/test/mongoid_traffic/log_test.rb

@@ -4,7 +4,7 @@ require_relative '../../lib/mongoid_traffic/log'
 
 module MongoidTraffic
   describe 'Log' do
-    subject { Log.new }
+    subject { MyLog.new }
 
     describe 'fields' do
       it 'has :scope' do
@@ -36,20 +36,20 @@ module MongoidTraffic
 
     describe 'scopes' do
       it 'has :default_scope that assumes no :scope' do
-        Log.criteria.selector.fetch('s').must_be_nil
+        MyLog.criteria.selector.fetch('s').must_be_nil
       end
 
-      it('has :for_dates') { Log.must_respond_to :for_dates }
-      it('has :yearly') { Log.must_respond_to :yearly }
-      it('has :monthly') { Log.must_respond_to :monthly }
-      it('has :weekly') { Log.must_respond_to :weekly }
-      it('has :daily') { Log.must_respond_to :daily }
-      it('has :scoped_to') { Log.must_respond_to :scoped_to }
+      it('has :for_dates') { MyLog.must_respond_to :for_dates }
+      it('has :yearly') { MyLog.must_respond_to :yearly }
+      it('has :monthly') { MyLog.must_respond_to :monthly }
+      it('has :weekly') { MyLog.must_respond_to :weekly }
+      it('has :daily') { MyLog.must_respond_to :daily }
+      it('has :scoped_to') { MyLog.must_respond_to :scoped_to }
     end
 
     describe '.aggregate_on' do
-      let(:log_1) { Log.new(date_from: Date.today, date_to: Date.today) }
-      let(:log_2) { Log.new(date_from: Date.tomorrow, date_to: Date.tomorrow) }
+      let(:log_1) { MyLog.new(date_from: Date.today, date_to: Date.today) }
+      let(:log_2) { MyLog.new(date_from: Date.tomorrow, date_to: Date.tomorrow) }
       
       describe '.aggregate_on(:access_count)' do
         before do
@@ -58,7 +58,7 @@ module MongoidTraffic
         end
 
         it 'sums the access_counts' do
-          Log.aggregate_on(:access_count).must_equal 3
+          MyLog.aggregate_on(:access_count).must_equal 3
         end
       end
 
@@ -91,7 +91,7 @@ module MongoidTraffic
         end
 
         it 'sums the browsers' do
-          Log.aggregate_on(:browsers).must_equal({
+          MyLog.aggregate_on(:browsers).must_equal({
             "Mac" => { 
               "Saf" => { "8" => 11, "7" => 100 }, 
               "Chr" => { "3" => 5 } 
@@ -111,7 +111,7 @@ module MongoidTraffic
         end
 
         it 'sums the referers' do
-          Log.aggregate_on(:referers).must_equal({ 'google' => 110, 'apple' => 1100, 'ms' => 1 })
+          MyLog.aggregate_on(:referers).must_equal({ 'google' => 110, 'apple' => 1100, 'ms' => 1 })
         end
       end
 
@@ -122,7 +122,7 @@ module MongoidTraffic
         end
 
         it 'sums the countries' do
-          Log.aggregate_on(:countries).must_equal({ 'CZ' => 100, 'DE' => 10 })
+          MyLog.aggregate_on(:countries).must_equal({ 'CZ' => 100, 'DE' => 10 })
         end
       end
 
@@ -133,7 +133,7 @@ module MongoidTraffic
         end
 
         it 'sums the unique_ids' do
-          Log.aggregate_on(:unique_ids).must_equal({ '01234' => 100, '56789' => 200 })
+          MyLog.aggregate_on(:unique_ids).must_equal({ '01234' => 100, '56789' => 200 })
         end
       end
 
@@ -144,7 +144,7 @@ module MongoidTraffic
         end
 
         it 'sums the unique_ids' do
-          Log.sum(:unique_ids).must_equal 3
+          MyLog.sum(:unique_ids).must_equal 3
         end
       end
     end

data/test/mongoid_traffic/logger_test.rb

@@ -18,42 +18,42 @@ module MongoidTraffic
     describe 'ClassMethods' do
       describe '.log' do
         before do 
-          Logger.log(user_agent: user_agent_string, referer: referer, ip_address: ip_address, unique_id: unique_id)
-          Logger.log(scope: scope, user_agent: user_agent_string, referer: referer, ip_address: ip_address, unique_id: unique_id)
+          MongoidTraffic::Logger.log(::MyLog, user_agent: user_agent_string, referer: referer, ip_address: ip_address, unique_id: unique_id)
+          MongoidTraffic::Logger.log(::MyLog, scope: scope, user_agent: user_agent_string, referer: referer, ip_address: ip_address, unique_id: unique_id)
         end
 
         it 'logs for month' do
-          Log.monthly(month, year).count.must_equal 1
+          ::MyLog.monthly(month, year).count.must_equal 1
         end
         it 'logs for date' do
-          Log.daily(date).count.must_equal 1
+          ::MyLog.daily(date).count.must_equal 1
         end
         it 'logs for scope' do
-          Log.scoped_to(scope).count.must_equal 2
+          ::MyLog.scoped_to(scope).count.must_equal 2
         end
         it 'logs access_count' do
-          Log.first.access_count.must_equal 1
+          ::MyLog.first.access_count.must_equal 1
         end
         it 'logs user_agent' do
-          Log.first.browsers.fetch('Macintosh').fetch('Safari').fetch('8%2E0').must_equal 1
+          ::MyLog.first.browsers.fetch('Macintosh').fetch('Safari').fetch('8%2E0').must_equal 1
         end
         it 'logs referer' do
-          Log.first.referers.fetch('http%3A%2F%2Fwww%2Egoogle%2Ecom').must_equal 1
+          ::MyLog.first.referers.fetch('http%3A%2F%2Fwww%2Egoogle%2Ecom').must_equal 1
         end
         it 'logs country' do
-          Log.first.countries.fetch('DE').must_equal 1
+          ::MyLog.first.countries.fetch('DE').must_equal 1
         end
         it 'logs unique_id' do
-          Log.first.unique_ids.fetch('ABC').must_equal 1
+          ::MyLog.first.unique_ids.fetch('ABC').must_equal 1
         end
         it 'logs updated_at' do
-          Log.first.updated_at.must_be :present?
+          ::MyLog.first.updated_at.must_be :present?
         end
 
         describe 'when referer a bot' do
           let(:referer) { 'Googlebot/Test ( http://www.googlebot.com/bot.html)' }
           it 'does not create log' do
-            Log.exists?.must_equal false
+            ::MyLog.exists?.must_equal false
           end
         end
       end

data/test/test_helper.rb

@@ -40,4 +40,9 @@ DatabaseCleaner.strategy = :truncation
 class MiniTest::Spec
   before(:each) { DatabaseCleaner.start }
   after(:each) { DatabaseCleaner.clean }
-end
+end
+
+class MyLog
+  include Mongoid::Document
+  include MongoidTraffic::Log
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_traffic
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Tomas Celizna
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-15 00:00:00.000000000 Z
+date: 2015-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: geoip
@@ -174,6 +174,7 @@ files:
 - ".coveralls.yml"
 - ".gitignore"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - Guardfile