sleek 0.0.1

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+services:
+  - mongodb

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Gosha Arinich
+
+MIT License
+
+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,256 @@
+![Sleek](sleek.png)
+
+[![Build Status](https://travis-ci.org/goshakkk/sleek.png)](https://travis-ci.org/goshakkk/sleek)
+
+Sleek is a gem for doing analytics. It allows you to easily collect and
+analyze events that happen in your app.
+
+## Installation
+
+The easiest way to install Sleek is to add it to your Gemfile:
+
+```ruby
+gem "sleek"
+```
+
+Then, install it:
+
+```
+$ bundle install
+```
+
+Sleek requires MongoDB to work and assumes that you have Mongoid
+configured already.
+
+## Getting started
+
+### Namespacing
+
+Namespaces are a great way to organize entirely different buckets of
+data inside a single application. In Sleek, everything is namespaced.
+
+Creating a namespaced instance of Sleek is easy:
+
+```ruby
+sleek = Sleek[:my_namespace]
+```
+
+You then would just call everything on this instance.
+
+### Sending an Event
+
+The heart of analytics is in recording events. Events are things that
+happen in your app that you want to track. Events are stored in event
+buckets.
+
+In order to send an event, you would simply need to call
+`sleek.record`, passing the event bucket name and the event
+payload.
+
+```ruby
+sleek.record(:purchases, {
+  customer: { id: 1, name: "First Last", email: "first@last.com" },
+  items: [{ sku: "TSTITM1", name: "Test Item 1", price: 1999 }],
+  total: 1999
+})
+```
+
+### Analyzing Events
+
+#### Simple count
+
+There are a few methods of analyzing your data. The simplest one is
+counting. It, you guessed it, would count how many times the event has
+occurred.
+
+```ruby
+sleek.queries.count(:purchases)
+# => 42
+```
+
+#### Average
+
+In order to calculate average value, it's needed to additionally specify
+what property should the average be calculated based on:
+
+```ruby
+sleek.queries.average(:purchases, target_property: :total)
+# => 1999
+```
+
+#### Query with timeframe
+
+You can limit the scope of events that analysis is run on by adding the
+`:timeframe` option to any query call.
+
+```ruby
+sleek.queries.count(:purchases, timeframe: :this_day)
+# => 10
+```
+
+#### Query with interval
+
+Some kinds of applications may need to analyze trends in the data. Using
+intervals, you can break a timeframe into minutes, hours, days, weeks,
+or months. One can do so by passing the `:interval` option to any query
+call. Using `:interval` also requires that you specify `:timeframe`.
+
+```ruby
+sleek.queries.count(:purchases, timeframe: :this_2_days, interval: :daily)
+# => [
+#      {:timeframe=>#<Sleek::Timeframe 2013-01-01 00:00:00 UTC..2013-01-02 00:00:00 UTC>, :value=>10},
+#      {:timeframe=>#<Sleek::Timeframe 2013-01-02 00:00:00 UTC..2013-01-03 00:00:00 UTC>, :value=>24}
+#    ]
+```
+
+## Data analysis in more detail
+
+### Metrics
+
+The word "metrics" is used to describe analysis queries which return a
+single numeric value.
+
+### Count
+
+Count just counts the number of events recorded.
+
+```ruby
+sleek.queries.count(:bucket)
+# => 42
+```
+
+### Count unique
+
+It counts how many events have an unique value for a given property.
+
+```ruby
+sleek.queries.count_unique(:bucket, params)
+```
+
+You must pass the target property name in params like this:
+
+```ruby
+sleek.queries.count_unique(:purchases, target_property: "customer.id")
+# => 30
+```
+
+### Minimum
+
+It finds the minimum numeric value for a given property. All non-numeric
+values are ignored. If none of property values are numeric, the
+exception will be raised.
+
+```ruby
+sleek.queries.minimum(:bucket, params)
+```
+
+You must pass the target property name in params like this:
+
+```ruby
+sleek.queries.minimum(:purchases, target_property: "total")
+# => 10_99
+```
+
+### Maximum
+
+It finds the maximum numeric value for a given property. All non-numeric
+values are ignored. If none of property values are numeric, the
+exception will be raised.
+
+```ruby
+sleek.queries.maximum(:bucket, params)
+```
+
+You must pass the target property name in params like this:
+
+```ruby
+sleek.queries.maximum(:purchases, target_property: "total")
+# => 199_99
+```
+
+### Average
+
+The average query finds the average value for a given property.  All
+non-numeric values are ignored. If none of property values are numeric,
+the exception will be raised.
+
+```ruby
+sleek.queries.average(:bucket, params)
+```
+
+You must pass the target property name in params like this:
+
+```ruby
+sleek.queries.average(:purchases, target_property: "total")
+# => 49_35
+```
+
+### Sum
+
+The sum query sums all the numeric values for a given property. All
+non-numeric values are ignored. If none of property values are numeric,
+the exception will be raised.
+
+```ruby
+sleek.queries.sum(:bucket, params)
+```
+
+You must pass the target property name in params like this:
+
+```ruby
+sleek.queries.sum(:purchases, target_property: "total")
+# => 2_072_70
+```
+
+## Filters
+
+To limit the scope of events used in analysis you can use a filter. To
+do so, you just pass the `:filter` option to the query.
+
+A single filter is a 3-element array, consisting of:
+
+* `property_name` - the property name to filter.
+* `operator` - the name of the operator to apply.
+* `value` - the value used in operator to compare to property value.
+
+Operators: eq, ne, lt, lte, gt, gte, in.
+
+You can pass either a single filter or an array of filters.
+
+```ruby
+sleek.queries.count(:purchases, filters: [:total, :gt, 1599])
+# => 20
+```
+
+## Series
+
+Series allow you to analyze trends in metrics over time. They break a
+timeframe into intervals and compute the metric for those intervals.
+
+Calculating series is simply done by adding the `:timeframe` and
+`:interval` options to the metric query.
+
+Valid intervals are:
+
+* `:hourly`
+* `:daily`
+* `:weekly`
+* `:monthly`
+
+## Other
+
+### Deleting buckets
+
+```ruby
+sleek.delete_bucket(:purchases)
+```
+
+### Deleting property from all events in the bucket
+
+```ruby
+sleek.delete_property(:purchases, :some_property)
+```
+
+## License
+
+[MIT](LICENSE).

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task default: :spec

data/lib/sleek/base.rb

@@ -0,0 +1,52 @@
+module Sleek
+  class Base
+    attr_reader :namespace
+
+    # Internal: Initialize Sleek with namespace.
+    #
+    # namespace - the Symbol namespace name.
+    def initialize(namespace)
+      @namespace = namespace
+    end
+
+    # Public: Record an event.
+    #
+    # bucket  - the String name of bucket.
+    # payload - the Hash of event data.
+    def record(bucket, payload)
+      Event.create_with_namespace(namespace, bucket, payload)
+    end
+
+    # Public: Get `QueriesCollection` for the namespace.
+    def queries
+      @queries ||= QueryCollection.new(namespace)
+    end
+
+    # Public: Delete event bucket.
+    #
+    # bucket - the String bucket name.
+    def delete_bucket(bucket)
+      events(bucket).delete_all
+    end
+
+    # Public: Delete specific property from all events in the bucket.
+    #
+    # bucket   - the String bucket name.
+    # property - the String property name.
+    def delete_property(bucket, property)
+      events(bucket).unset("d.#{property}")
+    end
+
+    # Internal: Get events associated with current namespace and,
+    # optionally, specified bucket.
+    def events(bucket = nil)
+      evts = Event.where(namespace: namespace)
+      evts = evts.where(bucket: bucket) if bucket.present?
+      evts
+    end
+
+    def inspect
+      "#<Sleek::Base ns=#{namespace}>"
+    end
+  end
+end

data/lib/sleek/core_ext/range.rb

@@ -0,0 +1,44 @@
+class Range
+  # Public: Convert both ends of range to integers.
+  def to_i_range
+    self.begin.to_i..self.end.to_i
+  end
+
+  # Public: Convert both ends of range to times.
+  def to_time_range
+    Time.at(self.begin)..Time.at(self.end)
+  end
+
+  def int_range?
+    self.begin.is_a?(Integer)
+  end
+
+  # Public: Check if range elements are times.
+  def time_range?
+    self.begin.is_a?(Time)
+  end
+
+  # Public: Calculate the differentce between ends of the range.
+  def difference
+    self.end - self.begin
+  end
+
+  # Public: Make up a range for previous n periods.
+  # Start of new range would be start of current - difference between
+  # start and end * number of periods, end of new range would be start of
+  # current.
+  #
+  # Example
+  #
+  #   (1200..1300).previous
+  #   # => 1100..1200
+  def previous(n = 1)
+    new_begin = self.begin - difference * n
+    new_end = self.end - difference * n
+    new_begin..new_end
+  end
+
+  def -(what)
+    (self.begin - what)..(self.end - what)
+  end
+end

data/lib/sleek/core_ext/time.rb

@@ -0,0 +1,2 @@
+class Time
+end

data/lib/sleek/event.rb

@@ -0,0 +1,37 @@
+module Sleek
+  class EventMetadata
+    include Mongoid::Document
+    include Mongoid::Timestamps::Created::Short
+
+    field :t, type: Time, as: :timestamp
+    embedded_in :event
+
+    before_create :set_timestamp
+
+    def set_timestamp
+      self.timestamp = created_at unless timestamp
+    end
+  end
+
+  class Event
+    include Mongoid::Document
+
+    field :ns, type: Symbol, as: :namespace
+    field :b, type: String, as: :bucket
+    field :d, type: Hash, as: :data
+    embeds_one :sleek, store_as: "s", class_name: 'Sleek::EventMetadata', cascade_callbacks: true
+    accepts_nested_attributes_for :sleek
+
+    validates :namespace, presence: true
+    validates :bucket, presence: true
+
+    after_initialize { build_sleek }
+
+    def self.create_with_namespace(namespace, bucket, payload)
+      sleek = payload.delete(:sleek)
+      event = create(namespace: namespace, bucket: bucket, data: payload)
+      event.sleek.update_attributes sleek
+      event
+    end
+  end
+end

data/lib/sleek/filter.rb

@@ -0,0 +1,24 @@
+module Sleek
+  class Filter
+    attr_reader :property_name, :operator, :value
+
+    def initialize(property_name, operator, value)
+      @property_name = "d.#{property_name}"
+      @operator = operator.to_sym
+      @value = value
+
+      unless [:eq, :ne, :lt, :lte, :gt, :gte, :in].include? @operator
+        raise ArgumentError, "unsupported operator - #{operator}"
+      end
+    end
+
+    def apply(criteria)
+      criteria.send(operator, property_name => value)
+    end
+
+    def ==(other)
+      other.is_a?(Filter) && property_name == other.property_name &&
+        operator == other.operator && value == other.value
+    end
+  end
+end

data/lib/sleek/interval.rb

@@ -0,0 +1,41 @@
+module Sleek
+  class Interval
+    def self.interval_value(desc)
+      case desc
+      when :hourly
+        1.hour
+      when :daily
+        1.day
+      when :weekly
+        1.week
+      when :monthly
+        1.month
+      else
+        raise ArgumentError, "invalid interval description"
+      end
+    end
+
+    attr_reader :interval, :timeframe
+
+    # Internal: Initialize an interval.
+    #
+    # interval_desc - the Symbol description of the interval.
+    #                 Possible values: :hourly, :daily, :weekly,
+    #                 :monthly.
+    # timeframe     - the Timeframe object.
+    def initialize(interval_desc, timeframe)
+      @interval = self.class.interval_value(interval_desc)
+      @timeframe = timeframe
+    end
+
+    # Internal: Split the timeframe into intervals.
+    #
+    # Returns an Array of Timeframe objects.
+    def timeframes
+      @timeframes ||= timeframe.to_time_range.to_i_range.each_slice(interval)
+        .to_a[0..-2]
+        .map { |tf| (tf.first..(tf.first + interval)).to_time_range }
+        .map { |tf| Timeframe.new(tf) }
+    end
+  end
+end

data/lib/sleek/queries/average.rb

@@ -0,0 +1,21 @@
+module Sleek
+  module Queries
+    # Internal: Average query.
+    #
+    # Finds the average value for a given property.
+    #
+    # target_property - the String name of target property on event.
+    #
+    # Examples
+    #
+    #   sleek.queries.average(:purchases, target_property: "total")
+    #   # => 49_35
+    class Average < Query
+      include Targetable
+
+      def perform(events)
+        events.avg target_property
+      end
+    end
+  end
+end

data/lib/sleek/queries/count.rb

@@ -0,0 +1,17 @@
+module Sleek
+  module Queries
+    # Internal: Count query.
+    #
+    # Simply counts events.
+    #
+    # Examples
+    #
+    #   sleek.queries.count(:purchases)
+    #   # => 42
+    class Count < Query
+      def perform(events)
+        events.count
+      end
+    end
+  end
+end

data/lib/sleek/queries/count_unique.rb

@@ -0,0 +1,21 @@
+module Sleek
+  module Queries
+    # Internal: Count unique query.
+    #
+    # Counts how many events have unique value for a given property.
+    #
+    # target_property - the String name of target property on event.
+    #
+    # Examples
+    #
+    #   sleek.queries.count_unique(:purchases, target_property: "customer.email")
+    #   # => 4
+    class CountUnique < Query
+      include Targetable
+
+      def perform(events)
+        events.distinct(target_property).count
+      end
+    end
+  end
+end

data/lib/sleek/queries/maximum.rb

@@ -0,0 +1,21 @@
+module Sleek
+  module Queries
+    # Internal: Maximum query.
+    #
+    # Finds the maximum value for a given property.
+    #
+    # target_property - the String name of target property on event.
+    #
+    # Examples
+    #
+    #   sleek.queries.maximum(:purchases, target_property: "total")
+    #   # => 199_99
+    class Maximum < Query
+      include Targetable
+
+      def perform(events)
+        events.max target_property
+      end
+    end
+  end
+end

data/lib/sleek/queries/minimum.rb

@@ -0,0 +1,21 @@
+module Sleek
+  module Queries
+    # Internal: Minimum query.
+    #
+    # Finds the minimum value for a given property.
+    #
+    # target_property - the String name of target property on event.
+    #
+    # Examples
+    #
+    #   sleek.queries.minimum(:purchases, target_property: "total")
+    #   # => 19_99
+    class Minimum < Query
+      include Targetable
+
+      def perform(events)
+        events.min target_property
+      end
+    end
+  end
+end