octocore-cassandra 0.0.6

data/lib/octocore-cassandra/stats.rb

@@ -0,0 +1,33 @@
+require 'statsd-ruby'
+
+module Octo
+
+  # Instrumentation and Statistical module
+  module Stats
+
+    # Instrument a block identified by its name
+    # @param [Symbol] name The name by which this would be identified
+    def instrument(name)
+      if stats
+        stats.time(name.to_s, &Proc.new)
+      else
+        yield
+      end
+    end
+
+    # Get stats instance
+    def stats
+      if statd_config
+        @statsd = Statsd.new(*statd_config.values) unless @statsd
+        @statsd
+      end
+    end
+
+    private
+
+    # Get stats config from Octo
+    def statd_config
+      Octo.get_config :statsd
+    end
+  end
+end

data/lib/octocore-cassandra/trendable.rb

@@ -0,0 +1,88 @@
+require 'octocore-cassandra/kldivergence'
+require 'octocore-cassandra/counter'
+
+module Octo
+
+  module Trendable
+
+    include Octo::KLDivergence
+
+    # Define the columns necessary for a trendable model
+    def trendables
+      column :divergence, :float
+      column :obp, :float
+    end
+
+    # Define the baseline class for this trend
+    def baseline(klass)
+      @baseline_klass = klass
+    end
+
+    # Define the class for trends
+    def trends_class(klass)
+      @trends_klass = klass
+    end
+
+    # Aggregates and attempts to store it into the database. This would only
+    #   work if the class that extends Octo::Counter includes from
+    #   Cequel::Record
+    def aggregate!(ts = Time.now.floor)
+      unless self.ancestors.include?Cequel::Record
+        raise NoMethodError, 'aggregate! not defined for this counter'
+      end
+
+      aggr = aggregate(ts)
+      sum = aggregate_sum(aggr)
+      aggr.each do |_ts, counterVals|
+        counterVals.each do |obj, count|
+          counter = self.new
+          counter.enterprise_id = obj.enterprise.id
+          counter.uid = obj.unique_id
+          counter.count = count
+          counter.type = Octo::Counter::TYPE_MINUTE
+          counter.ts = _ts
+          totalCount = sum[_ts][obj.enterprise_id.to_s].to_f
+          counter.obp = (count * 1.0)/totalCount
+
+          baseline_value = get_baseline_value(:TYPE_MINUTE, obj)
+          counter.divergence = kl_divergence(counter.obp,
+                                             baseline_value)
+          counter.save!
+        end
+      end
+      call_completion_hook(Octo::Counter::TYPE_MINUTE, ts)
+    end
+
+    private
+
+    # Aggregates to find the sum of all counters for an enterprise
+    #   at a time
+    # @param [Hash] aggr The aggregated hash
+    # @return [Hash] The summed up hash
+    def aggregate_sum(aggr)
+      sum = {}
+      aggr.each do |ts, counterVals|
+        sum[ts] = {} unless sum.has_key?ts
+        counterVals.each do |obj, count|
+          if obj.respond_to?(:enterprise_id)
+            eid = obj.public_send(:enterprise_id).to_s
+            sum[ts][eid] = sum[ts].fetch(eid, 0) + count
+          end
+        end
+      end
+      sum
+    end
+
+    # Get the baseline value for an object.
+    # @param [Fixnum] baseline_type The type of baseline to fetch
+    # @param [Object] object The object for which baseline is to
+    #   be fetched
+    def get_baseline_value(baseline_type, object)
+      clazz = @baseline_klass.constantize
+      clazz.public_send(:get_baseline_value, baseline_type, object)
+    end
+
+
+  end
+
+end

data/lib/octocore-cassandra/trends.rb

@@ -0,0 +1,158 @@
+require 'octocore-cassandra/baseline'
+require 'octocore-cassandra/counter'
+
+module Octo
+
+  module Trends
+
+    include Octo::Counter::Helper
+
+    DEFAULT_COUNT = 10
+
+    # Define the columns needed for Trends
+    def trendable
+      key :type, :int
+      key :ts, :timestamp
+      key :rank, :int
+
+      column :score, :float
+      column :uid, :text
+
+      generate_aggregators { |ts, method|
+        trendtype = method_names_type_counter(method)
+        aggregate_and_create trendtype, ts
+      }
+
+    end
+
+    # Aggregates and creates trends for all the enterprises for a specific
+    #   trend type at a specific timestamp
+    # @param [Fixnum] oftype The type of trend to be calculated
+    # @param [Time] ts The time at which trend needs to be calculated
+    def aggregate_and_create(oftype, ts = Time.now.floor)
+      Octo::Enterprise.each do |enterprise|
+        calculate(enterprise.id, oftype, ts)
+      end
+    end
+
+    # Override the aggregate! defined in counter class as the calculations
+    #   for trending are a little different
+    def aggregate!(ts = Time.now.floor)
+      aggregate_and_create(Octo::Counter::TYPE_MINUTE, ts)
+    end
+
+    # Performs the actual trend calculation
+    # @param [String] enterprise_id The enterprise ID for whom trend needs to be found
+    # @param [Fixnum] trend_type The trend type to be calculates
+    # @param [Time] ts The Timestamp at which trend needs to be calculated.
+    def calculate(enterprise_id, trend_type, ts = Time.now.floor)
+        args = {
+          enterprise_id: enterprise_id,
+          ts: ts,
+          type: trend_type
+        }
+
+        klass = @trend_for.constantize
+        hitsResult = klass.public_send(:where, args)
+        trends = hitsResult.map { |h| counter2trend(h) }
+
+        # group trends as per the time of their happening and rank them on their
+        # score
+        grouped_trends = trends.group_by { |x| x.ts }
+        grouped_trends.each do |_ts, trendlist|
+          sorted_trendlist = trendlist.sort_by { |x| x.score }
+          sorted_trendlist.each_with_index do |trend, index|
+            trend.rank = index
+            trend.type = trend_type
+            trend.save!
+          end
+        end
+    end
+
+    # Define the class for which trends shall be found
+    def trend_for(klass)
+      unless klass.constantize.ancestors.include?Cequel::Record
+        raise ArgumentError, "Class #{ klass } does not represent a DB Model"
+      else
+        @trend_for = klass
+      end
+    end
+
+    # Define the class which would be returned while fetching trending objects
+    def trend_class(klass)
+      @trend_class = klass
+    end
+
+    # Gets the trend of a type at a time
+    # @param [String] enterprise_id The ID of enterprise for whom trend to fetch
+    # @param [Fixnum] type The type of trend to fetch
+    # @param [Hash] opts The options to be provided for finding trends
+    def get_trending(enterprise_id, type, opts={})
+      ts = opts.fetch(:ts, Time.now.floor)
+      args = {
+        enterprise_id: enterprise_id,
+        ts: opts.fetch(:ts, Time.now.floor),
+        type: type
+      }
+      res = where(args).limit(opts.fetch(:limit, DEFAULT_COUNT))
+      enterprise = Octo::Enterprise.find_by_id(enterprise_id)
+      if res.count == 0 and enterprise.fakedata?
+        Octo.logger.info 'Beginning to fake data'
+        res = []
+        if ts.class == Range
+          ts_begin = ts.begin
+          ts_end = ts.end
+          ts_begin.to(ts_end, 1.day).each do |_ts|
+            3.times do |rank|
+              items = @trend_class.constantize.send(:where, {enterprise_id: enterprise_id}).first(10)
+              if items.count > 0
+                uid = items.shuffle.pop.unique_id
+                _args = args.merge( ts: _ts, rank: rank, score: rank+1, uid: uid )
+                res << self.new(_args).save!
+              end
+            end
+          end
+        elsif ts.class == Time
+          3.times do |rank|
+            uid = 0
+            items = @trend_class.constantize.send(:where, {enterprise_id: enterprise_id}).first(10)
+            if items.count > 0
+              uid = items.shuffle.pop.unique_id
+              _args = args.merge( rank: rank, score: rank+1, uid: uid )
+              res << self.new(_args).save!
+            end
+          end
+        end
+      end
+      res.map do |r|
+        clazz = @trend_class.constantize
+        clazz.public_send(:recreate_from, r)
+      end
+    end
+
+    private
+
+    # Converts a couunter into a trend
+    # @param [Object] counter A counter object. This object must belong
+    #   to one of the counter types defined in models.
+    # @return [Object] Returns a trend instance corresponding to the counter
+    #   instance
+    def counter2trend(counter)
+      self.new({
+        enterprise: counter.enterprise,
+        score: score(counter.divergence),
+        uid: counter.uid,
+        ts: counter.ts
+      })
+    end
+
+    # For now, just make sure divergence is absolute. This is responsible to
+    #   score a counter on the basis of its divergence
+    # @param [Float] divergence The divergence value
+    # @return [Float] The score
+    def score(divergence)
+      return 0 if divergence.nil?
+      divergence.abs
+    end
+  end
+end

data/lib/octocore-cassandra/utils.rb

@@ -0,0 +1,90 @@
+require 'set'
+
+module Octo
+
+  module Utils
+
+    class << self
+
+      # Serialize one record before adding it to the cache. Creates a ruby byte
+      #   stream
+      # @param [Object] record Any object to be serialized
+      def serialize(record)
+        Marshal::dump(record).to_s
+      end
+
+      # Deserialize a data.
+      # @param [String] data A string containing Marshal dump of the object
+      def deserialize(data)
+        Marshal::load(data)
+      end
+    end
+  end
+end
+
+class ::Time
+
+  # Find floor time
+  # @param [Fixnum] height The minutes of height for floor. Defaults to 1
+  def floor(height = 1)
+    if height < 1
+      height = 1
+    end
+    sec = height.to_i * 60
+    Time.at((self.to_i / sec).round * sec)
+  end
+
+  # Find ceil time
+  # @param [Fixnum] height The minutes of height for ceil. Defaults to 1
+  def ceil(height = 1)
+    if height < 1
+      height = 1
+    end
+    sec = height.to_i * 60
+    Time.at((1 + (self.to_i / sec)).round * sec)
+  end
+
+  # Finds the steps between two time.
+  # @param [Time] to The end time
+  # @param [Time] step The step time. Defaults to 15.minute
+  # @return [Array<Time>] An array containint times
+  def to(to, step = 15.minutes)
+    [self].tap { |array| array << array.last + step while array.last < to }
+  end
+
+end
+
+class ::String
+
+  # Create a custom method to convert strings to Slugs
+  def to_slug
+    #strip the string
+    ret = self.strip
+
+    #blow away apostrophes
+    ret.gsub!(/['`]/,'')
+
+    # @ --> at, and & --> and
+    ret.gsub!(/\s*@\s*/, ' at ')
+    ret.gsub!(/\s*&\s*/, ' and ')
+
+    #replace all non alphanumeric, underscore or periods with underscore
+    ret.gsub!(/\s*[^A-Za-z0-9\.\-]\s*/, '_')
+
+    #convert double underscores to single
+    ret.gsub!(/_+/,'_')
+
+    #strip off leading/trailing underscore
+    ret.gsub!(/\A[_\.]+|[_\.]+\z/,'')
+
+    ret
+  end
+
+end
+
+class ::Hash
+  def deep_merge(second)
+    merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : Array === v1 && Array === v2 ? v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2 }
+    self.merge(second.to_h, &merger)
+  end
+end

data/lib/octocore-cassandra/version.rb

@@ -0,0 +1,4 @@
+module Octo
+  # The current version of the library
+  VERSION = '0.0.6'
+end

data/spec/lib/stats_spec.rb

@@ -0,0 +1,20 @@
+require_relative '../spec_helper'
+
+describe Octo::Stats do
+
+    describe '#instrument' do
+     let(:dummy_class) { Class.new { extend Octo::Stats } }
+
+      it 'yields the given block' do
+        block = Proc.new { puts 'hello world' }
+        name = :hello_world
+
+        expect(dummy_class).to receive(:instrument).
+            with(name, &block).
+            and_yield(&block)
+
+        dummy_class.instrument(name, &block)
+      end
+    end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,103 @@
+require 'bundler/setup'
+require 'rspec'
+
+Bundler.setup
+
+require 'octocore'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end