wonkavision 0.5.11 → 0.6.0

data/CHANGELOG.rdoc

@@ -1,3 +1,6 @@
+== 0.6.0
+ * Initial, experimental draft of real time analytics framework.
+
 == 0.5.11
  * Guess that last change doesn't work in Rails 3 :) Fixed things up a different way to get the same effect, but more compatible.
 

data/lib/wonkavision.rb

@@ -1,6 +1,7 @@
 require "rubygems"
 require "active_support"
 require "active_support/hash_with_indifferent_access" unless defined?(HashWithIndifferentAccess)
+require "active_support/core_ext"
 
 dir = File.dirname(__FILE__)
 ["support",
@@ -9,9 +10,12 @@ dir = File.dirname(__FILE__)
  "event",
  "event_context",
  "event_namespace",
+ "local_job_queue",
  "event_coordinator",
  "event_binding",
  "event_handler",
+ "facts",
+ "aggregation",
  "message_mapper/indifferent_access",
  "message_mapper/map",
  "message_mapper",
@@ -20,14 +24,33 @@ dir = File.dirname(__FILE__)
  "plugins/business_activity/event_binding",
  "plugins/business_activity",
  "plugins/timeline",
+ "extensions/symbol",
+ "plugins/analytics/member_filter",
+ "plugins/analytics/persistence/store",
+ "plugins/analytics/persistence/hash_store",
+ "plugins/analytics/facts",
+ "plugins/analytics/aggregation/aggregation_spec",
+ "plugins/analytics/aggregation/attribute",
+ "plugins/analytics/aggregation/dimension",
+ "plugins/analytics/aggregation/measure",
+ "plugins/analytics/aggregation",
+ "plugins/analytics/cellset",
+ "plugins/analytics/query",
  "acts_as_oompa_loompa",
  "persistence/mongo_mapper_adapter",
- "persistence/mongoid_adapter"].each {|lib|require File.join(dir,'wonkavision',lib)}
+ "persistence/mongoid_adapter",
+ "plugins/analytics/mongo"
+].each {|lib|require File.join(dir,'wonkavision',lib)}
+
+
+
 
 #require File.join(dir,"cubicle","mongo_mapper","aggregate_plugin") if defined?(MongoMapper::Document)
 
 module Wonkavision
 
+   NaN = 0.0 / 0.0
+
 #  def self.register_cubicle_directory(directory_path, recursive=true)
 #    searcher = "#{recursive ? "*" : "**/*"}.rb"
 #    Dir[File.join(directory_path,searcher)].each {|cubicle| require cubicle}
@@ -73,3 +96,7 @@ module Wonkavision
 
 
 end
+
+#Load event handlers for analytics
+# dir = File.dirname(__FILE__)
+Dir[File.join(dir,"wonkavision","plugins/analytics/handlers/**/*.rb")].each {|lib|require lib}

data/lib/wonkavision/aggregation.rb

@@ -0,0 +1,21 @@
+module Wonkavision
+  module Aggregation
+
+    def self.all
+      Wonkavision::Plugins::Aggregation.all
+    end
+
+    def self.persistence
+      @persistence
+    end
+
+    def self.included(handler)
+      handler.class_eval do
+        extend Plugins
+        use Plugins::Aggregation
+      end
+
+      super
+    end
+  end
+end

data/lib/wonkavision/event_coordinator.rb

@@ -2,11 +2,13 @@ module Wonkavision
   class EventCoordinator
 
     attr_reader :root_namespace
+    attr_accessor :broadcast_transport, :job_queue
 
     def initialize
       @root_namespace = Wonkavision::EventNamespace.new
-      @lock = Mutex.new
+      #@lock = Mutex.new
       #@event_cache = {}
+
       @incoming_event_filters = []
     end
 
@@ -22,7 +24,7 @@ module Wonkavision
       self.instance_eval(&block)
     end
 
-    def map ()
+    def map
       yield root_namespace if block_given?
     end
 
@@ -33,17 +35,27 @@ module Wonkavision
     end
 
     def receive_event(event_path, event_data)
-      @lock.synchronize do
-                          #If process_incoming_event returns nil or false, it means a filter chose to abort
-                          #the event processing, in which case we'll break for lunch.
+      #@lock.synchronize do
+        #If process_incoming_event returns nil or false, it means a filter chose to abort
+        #the event processing, in which case we'll break for lunch.
         return unless event_data = process_incoming_event(event_path,event_data)
 
         event_path = Wonkavision.normalize_event_path(event_path)
         targets = root_namespace.find_matching_segments(event_path).values
-        #If the event wasn't matched, maybe someone is subscribing to '/*' ? 
+        #If the event wasn't matched, maybe someone is subscribing to '/*' ?
         targets = [root_namespace] if targets.blank?
         targets.each{|target|target.notify_subscribers(event_data,event_path)}
-      end
+      #end
+    end
+
+    def publish(event_path, event_data)
+      raise "No transport was configured with the EventCoordinator to deliver broadcast messages. Please set Wonkavision.event_coordinator.broadcast_transport = <some transport>." unless broadcast_transport
+      broadcast_transport.publish(event_path, event_data)
+    end
+
+    def submit_job(event_path, event_data)
+      job_queue ? job_queue.publish(event_path,event_data) :
+        receive_event(event_path, event_data)
     end
 
     protected

data/lib/wonkavision/extensions/symbol.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+# This concept is torn from the chest cavity of
+# jnunemakers plucky library (https://github.com/jnunemaker/plucky/blob/master/lib/plucky/extensions/symbol.rb)
+module Wonkavision
+  module Extensions
+    module Symbol
+
+      [:key, :caption, :sort].each do |dimension_attribute|
+        define_method(dimension_attribute) do
+          _filter(dimension_attribute, :member_type=>:dimension)
+        end unless method_defined?(dimension_attribute)
+      end
+
+      [:sum, :sum2, :count].each do |measure_attribute|
+        define_method(measure_attribute) do
+          _filter(measure_attribute, :member_type=>:measure)
+        end unless method_defined?(measure_attribute)
+      end
+
+      def[](name)
+        _filter(name)
+      end
+
+      def method_missing(name,*args)
+        _filter(name)
+      end
+
+      private
+      def _member_type
+        self == :measures ? :measure : :dimension
+      end
+
+      def _is_member_name?
+        [:dimensions,:measures].include?(self) == false
+      end
+
+       def _filter(name, options={})
+        options[:member_type] ||= _member_type
+        if _is_member_name?
+          member_name = self
+          options[:attribute_name] = name
+        else
+          member_name = name
+        end
+        Wonkavision::Analytics::MemberFilter.new(member_name,options)
+      end
+
+    end
+  end
+end
+
+
+class Symbol
+  include Wonkavision::Extensions::Symbol
+end

data/lib/wonkavision/facts.rb

@@ -0,0 +1,27 @@
+module Wonkavision
+  module Facts
+
+  def self.persistence
+      @persistence
+    end
+
+    #current only supports :mongo
+    def self.persistence=(backend)
+      case backend
+      when :mongo then require File.dirname(__FILE__) + "/plugins/analytics/mongo"
+      else
+        raise "#{backend} is not a supported back end for Wonkavision analytics"
+      end
+      @persistence = backend
+    end
+
+    def self.included(facts)
+      facts.class_eval do
+        extend Plugins
+        use Plugins::EventHandling
+        use Plugins::Callbacks
+        use Plugins::Facts
+      end
+    end
+  end
+end

data/lib/wonkavision/local_job_queue.rb

@@ -0,0 +1,28 @@
+require 'thread'
+
+module Wonkavision
+  class LocalJobQueue
+    attr_reader :queue
+    def initialize(options={})
+      worker_count = options[:workers] || 2
+      @queue = Queue.new
+      @workers = []
+      worker_count.times do
+        Thread.new do
+          while true
+            if msg = @queue.pop
+              Wonkavision.event_coordinator.receive_event(msg[0],msg[1])
+            else
+              sleep 0.1
+            end
+          end
+        end
+      end
+    end
+
+    def publish(event_path,event)
+      @queue << [event_path, event]
+    end
+
+  end
+end

data/lib/wonkavision/message_mapper.rb

@@ -11,11 +11,11 @@ module Wonkavision
         MessageMapper.maps[map_name] = block
       end
 
-      def execute(map,data_source)
+      def execute(map,data_source,options={})
         map_block = map.kind_of?(Proc) ? map : MessageMapper.maps[map]
 
         raise "#{map} not found" unless map_block
-        MessageMapper::Map.new.execute(data_source, map_block)
+        MessageMapper::Map.new.execute(data_source, map_block, options)
       end
 
       def register_map_directory(directory_path, recursive=true)

data/lib/wonkavision/message_mapper/map.rb

@@ -5,12 +5,14 @@ module Wonkavision
       include IndifferentAccess
 
       def initialize(context = nil)
+  @write_nils = true
         @context_stack = []
         @context_stack.push(context) if context
         @formats = default_formats
       end
 
-      def execute(context,map_block)
+      def execute(context,map_block,options={})
+        @write_nils = options[:write_nils].nil? ? true : options[:write_nils]
         @context_stack.push(context)
         instance_eval(&map_block)
         @context_stack.clear
@@ -25,6 +27,14 @@ module Wonkavision
         @context_stack[-1]
       end
 
+      def ignore_nil!
+        @write_nils = false
+      end
+
+      def write_nil!
+        @write_nils = true
+      end
+
       def from (context,&block)
         raise "No block ws provided to 'from'" unless block
         return if context.nil?
@@ -146,7 +156,7 @@ module Wonkavision
           if kind_of?(Date)
             self
           elsif respond_to?(:to_date)
-            to_time
+            to_date
           elsif (date_str=to_s) && date_str.length > 0
             begin
               Date.parse(date_str)
@@ -187,7 +197,45 @@ module Wonkavision
         end
       end
 
+      def duration(*args, &block)
+        opts = args.extract_options! || {}
+
+        from = opts.delete(:from)
+        to = opts.delete(:to)
+
+        return nil unless from || to
+
+        from ||= Time.now; to ||= Time.now
+
+        unit = opts.delete(:in) || opts.delete(:unit) || :seconds
+
+        duration = convert_seconds(to-from,unit)
+
+        assignment = {args.shift => duration}
+        args << assignment << opts
+
+        value(*args, &block)
+
+      end
+      alias :elapsed :duration
+
       private
+
+      def convert_seconds(duration, unit)
+        duration /
+        case unit.to_s
+                         when "seconds" then 1
+                         when "minutes" then 60
+                         when "hours" then 60 * 60
+                         when "days" then 60 * 60 * 24
+                         when "weeks" then 60 * 60 * 24 * 7
+                         when "months" then 60 * 60 * 24 * 30
+                         when "years" then 60 * 60 * 24 *  365
+                         else raise "Cannot convert duration to unknown time unit #{unit}"
+                         end
+
+      end
+
       def format_value(val,opts={})
         val = opts[:default] || opts[:default_value] if val.nil?
         return val if val.nil?
@@ -202,16 +250,18 @@ module Wonkavision
       end
 
       def extract_value_from_context(context,field_name,block=nil)
-        if context.respond_to?(field_name.to_sym)
-          value = context.instance_eval("self.#{field_name}")
-        elsif context.respond_to?(:[])
+        value = nil
+        if context.respond_to?(:[])
           value = context[field_name]
           if value.nil? && field_name
             value = context[field_name.to_sym] || context[field_name.to_s]
           end
-        else
-          value = nil
         end
+
+        if context.respond_to?(field_name.to_sym)
+          value = context.instance_eval("self.#{field_name}")
+        end unless value
+
         value = value.instance_eval(&block) if block
         value
       end
@@ -219,7 +269,9 @@ module Wonkavision
       def set_value(field_name,val,opts={})
         if prefix = opts[:prefix]; field_name = "#{prefix}#{field_name}"; end
         if suffix = opts[:suffix]; field_name = "#{field_name}#{suffix}"; end
-        self[field_name] = format_value(val,opts)
+        unless val.nil? && !@write_nils
+          self[field_name] = format_value(val,opts)
+        end
       end
 
       def default_formats

data/lib/wonkavision/persistence/mongo.rb

@@ -0,0 +1,95 @@
+# encoding: UTF-8
+# Taken almost verbatim from https://github.com/jnunemaker/mongomapper/blob/master/lib/mongo_mapper/connection.rb
+require 'uri'
+require 'mongo'
+
+module Wonkavision
+  module Mongo
+    extend self
+
+    def initialize(connection=nil)
+      @connection = connection
+    end
+
+    # @api public
+    def connection
+      @connection ||= ::Mongo::Connection.new
+    end
+
+    # @api public
+    def connection=(new_connection)
+      @connection = new_connection
+    end
+
+    # @api public
+    def logger
+      connection.logger
+    end
+
+    # @api public
+    def database=(name)
+      @database = nil
+      @database_name = name
+    end
+
+    # @api public
+    def database
+      if @database_name.blank?
+        raise 'You forgot to set the default database name: database = "foobar"'
+      end
+
+      @database ||= connection.db(@database_name)
+    end
+
+    def config=(hash)
+      @config = hash
+    end
+
+    def config
+      raise 'Set config before connecting. config = {...}' unless defined?(@config)
+      @config
+    end
+
+    # @api private
+    def config_for_environment(environment)
+      env = config[environment]
+      return env if env['uri'].blank?
+
+      uri = URI.parse(env['uri'])
+      raise InvalidScheme.new('must be mongodb') unless uri.scheme == 'mongodb'
+      {
+        'host'     => uri.host,
+        'port'     => uri.port,
+        'database' => uri.path.gsub(/^\//, ''),
+        'username' => uri.user,
+        'password' => uri.password,
+      }
+    end
+
+    def connect(environment, options={})
+      raise 'Set config before connecting. config = {...}' if config.blank?
+      env = config_for_environment(environment)
+      self.connection = ::Mongo::Connection.new(env['host'], env['port'], options)
+      self.database = env['database']
+      database.authenticate(env['username'], env['password']) if env['username'] && env['password']
+    end
+
+    def setup(config, environment, options={})
+      handle_passenger_forking
+      self.config = config
+      connect(environment, options)
+    end
+
+    def handle_passenger_forking
+      if defined?(PhusionPassenger)
+        PhusionPassenger.on_event(:starting_worker_process) do |forked|
+          connection.connect if forked
+        end
+      end
+    end
+
+    class Connection
+      include Wonkavision::Mongo
+    end
+  end
+end