mongoid_traffic 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7ad004c5822da4119392890d10e40e079e69d74d
+  data.tar.gz: 6a17ade80336a8373524d21abdeacf3654bbf108
+SHA512:
+  metadata.gz: 9973194e9d251f27e517e6e36269b6e1c012741c12251206e33e86bf1d2223bdd079cfda215da5fb37a5bf4c2a34edcbc7f5fd20bf0e28d2ed610d21cdcb82f2
+  data.tar.gz: 6f2f2c1d53fdfb573495d6473089274e70e241b33d8bcd33741511bc6d2a98a4621409914134aedc7a271f21ec1ed9c46f9bda7d62acd071d227eb29f9ca35de

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+cache: bundler
+script: 'bundle exec rake'
+rvm:
+  - 2.1.2
+services:
+  - mongodb
+
+notifications:
+  email:
+    recipients:
+      - tomas.celizna@gmail.com
+    on_failure: change
+    on_success: never

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,112 @@
+PATH
+  remote: .
+  specs:
+    mongoid_traffic (0.0.1)
+      geoip
+      mongoid (~> 4.0)
+      nokogiri
+      useragent (~> 0.10.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.1.4)
+      activesupport (= 4.1.4)
+      builder (~> 3.1)
+    activesupport (4.1.4)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      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)
+    coveralls (0.7.0)
+      multi_json (~> 1.3)
+      rest-client
+      simplecov (>= 0.7)
+      term-ansicolor
+      thor
+    database_cleaner (1.3.0)
+    docile (1.1.5)
+    ffi (1.9.3)
+    formatador (0.2.5)
+    geoip (1.4.0)
+    guard (2.6.1)
+      formatador (>= 0.2.4)
+      listen (~> 2.7)
+      lumberjack (~> 1.0)
+      pry (>= 0.9.12)
+      thor (>= 0.18.1)
+    guard-minitest (2.3.1)
+      guard (~> 2.0)
+      minitest (>= 3.0)
+    i18n (0.6.11)
+    json (1.8.1)
+    listen (2.7.9)
+      celluloid (>= 0.15.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.9)
+    method_source (0.8.2)
+    mime-types (1.25.1)
+    mini_portile (0.6.0)
+    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)
+      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)
+    optionable (0.2.0)
+    origin (2.1.1)
+    pry (0.10.0)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.3.2)
+    rb-fsevent (0.9.4)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    rest-client (1.7.2)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    simplecov (0.9.0)
+      docile (~> 1.1.0)
+      multi_json
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    slop (3.6.0)
+    term-ansicolor (1.3.0)
+      tins (~> 1.0)
+    thor (0.19.1)
+    thread_safe (0.3.4)
+    timers (1.1.0)
+    tins (1.3.1)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    useragent (0.10.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  coveralls
+  database_cleaner
+  guard
+  guard-minitest
+  minitest
+  mongoid_traffic!
+  rake

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :minitest do
+  watch(%r{^lib/(.+)\.rb$})                               { |m| "test/#{m[1]}_test.rb" }
+  watch(%r{^test/.+_test\.rb$})
+  watch(%r{^test/test_helper\.rb$})                       { 'test' }
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Tomas Celizna
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,229 @@
+# Mongoid Traffic
+
+[![Build Status](https://travis-ci.org/tomasc/mongoid_traffic.svg)](https://travis-ci.org/tomasc/mongoid_traffic) [![Gem Version](https://badge.fury.io/rb/mongoid_traffic.svg)](http://badge.fury.io/rb/mongoid_traffic) [![Coverage Status](https://img.shields.io/coveralls/tomasc/mongoid_traffic.svg)](https://coveralls.io/r/tomasc/mongoid_traffic)
+
+Aggregated traffic logs stored in MongoDB. Fast and efficient logging via atomic updates of nested hashes in small number of MongoDB documents, semi-fast retrieveal and aggregation.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```Ruby
+gem 'mongoid_traffic'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install mongoid_traffic
+```
+
+## Usage
+
+Log your traffic like this:
+
+```Ruby
+MongoidTraffic::Logger.log
+```
+
+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.
+
+### Optional arguments
+
+#### Time scope:
+
+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))
+```
+
+The available options are: `%(year month week day)`
+
+#### Scope:
+
+```Ruby
+MongoidTraffic::Logger.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)
+```
+
+Logs platform-browser-version access count:
+
+```Ruby
+{ "Macintosh" => { "Safari" => { "8%2E0" => 1, "7%2E1" => 2 } } }
+```
+
+Please note the keys are escaped. You might want to unescape them using for example `CGI::unescape`.
+
+#### Referer:
+
+```Ruby
+MongoidTraffic::Logger.log(referer: http_referer_string)
+```
+
+Logs referer access count:
+
+```Ruby
+{ "http%3A%2F%2Fwww%2Egoogle%2Ecom" => 1 }
+```
+
+Please note the keys are escaped. You might want to unescape them using for example `CGI::unescape`.
+
+If the referer is included in the [bot list](http://www.user-agents.org/allagents.xml) the log will not be created.
+
+#### Country (via IP address):
+
+```Ruby
+MongoidTraffic::Logger.log(ip_address: '123.123.123.123')
+```
+
+Logs access count by country code 2:
+
+```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.
+
+#### Unique id:
+
+```Ruby
+MongoidTraffic::Logger.log(unique_id: unique_id_string)
+```
+
+Logs access count by id:
+
+```Ruby
+{ "0123456789" => 100, "ABCDEFGHIJ" => 1 }
+```
+
+Typically you would pass it something like `session_id` to track unique visitors.
+
+## Rails
+
+In case of Rails, you can use the `.after_action` macro with the `#log_traffic` helper method in your controllers:
+
+```Ruby
+class MyController < ApplicationController
+	after_action :log_traffic, only: [:show]
+end
+```
+
+The method automatically infers most of the options from the controller `request` method (User-Agent, Referer, IP address) and unique id from the Rails session.
+
+Additionally the `:log_scoped_traffic` method adds a scope by the current request path (`/pages/123`):
+
+```Ruby
+class MyController < ApplicationController
+	after_action :log_scoped_traffic, only: [:show]
+end
+```
+
+You can override this behavior with custom scope like this:
+
+```Ruby
+class MyController < ApplicationController
+	after_action :log_scoped_traffic, only: [:show]
+
+	private
+	
+	def log_scoped_traffic
+		super scope: 'my-scope-comes-here'
+	end
+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
+class MyController < ApplicationController
+	after_action :log_traffic, only: [:show]
+	after_action :log_scoped_traffic, only: [:show]
+end
+```
+
+## Accessing the log
+
+The log is accessed with a combination of Mongoid Criteria and aggregation methods. 
+
+### Criteria
+
+The following time based criteria are predefined as Mongoid scopes:
+
+* `.yearly(year)`
+* `.monthly(month, year)`
+* `.weekly(week, year)`
+* `.daily(date)`
+
+To narrow down by scope:
+
+* `.scoped_to(scope)`
+
+### Aggregation method
+
+* `.aggregate_on(:access_count)`
+* `.aggregate_on(:browsers)`
+* `.aggregate_on(:referers)`
+* `.aggregate_on(:countries)`
+* `.aggregate_on(:unique_ids)`
+
+Behind the scenes, this method will take all documents returned by your criteria and combines the values of the specified field (in case of `:access_count` it is simple sum of the values, in other cases it is sum of nested hashes).
+
+### Unique visits
+
+Lastly, to retrieve the number of unique visits:
+
+* `.sum(:unique_ids)`
+
+### Examples
+
+Typically you first query by time:
+
+```Ruby
+Mongoid::TrafficLog.daily(Date.today)
+```
+
+And eventually by scope:
+
+```Ruby
+Mongoid::TrafficLog.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)
+```
+
+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)
+```
+
+## Further reading
+
+Based on the approach described by John Nunemaker [here](http://www.railstips.org/blog/archives/2011/06/28/counters-everywhere/) and [here](http://www.railstips.org/blog/archives/2011/07/31/counters-everywhere-part-2/).
+
+## Contributing
+
+1. Fork it ( https://github.com/tomasc/mongoid_traffic/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,26 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+ 
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+ 
+namespace :mongoid_traffic do
+  require File.dirname(__FILE__) + "/lib/mongoid_traffic/logger/bots"
+  require File.dirname(__FILE__) + "/lib/mongoid_traffic/logger/geo_ip"
+
+  desc "output the list of bots"
+  task :update_bots_data do
+    `cd vendor/mongoid_traffic && curl -O #{MongoidTraffic::Logger::Bots::DATA_URL}`
+  end
+
+  desc "output the geoip.dat"
+  task :update_geoip_data do
+    `cd vendor/mongoid_traffic && curl -O #{MongoidTraffic::Logger::GeoIp::DATA_URL}`
+    `cd vendor/mongoid_traffic && gunzip -f GeoIP.dat.gz`
+  end
+
+end
+
+task :default => :test