harbinger 0.0.1.pre → 0.1.0

data/lib/harbinger.rb

@@ -1,5 +1,104 @@
-require "harbinger/engine"
+require "harbinger/engine" if defined?(Rails)
 require "harbinger/version"
+require "harbinger/reporters"
+require "harbinger/channels"
+require "harbinger/exceptions"
+require "harbinger/configuration"
 
 module Harbinger
+  module_function
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+  end
+
+  module_function
+  def configure
+    yield(configuration)
+  end
+
+  # Responsible for building a :message from the various :contexts and then
+  # delivering the :message to the appropriate :channels.
+  #
+  # @see .build_message
+  # @see .deliver_message
+  #
+  # @param [Hash] options
+  # @option options [Message] :message The message you want to amend.
+  #   If none is provided, then one is created.
+  # @option options [Object, Array<Object>] :contexts One or more Objects that
+  #   Harbinger will visit and extract message elements from.
+  # @option options [Symbol, Array<Symbol>] :channels One or more channels that
+  #   Harbinger will deliver the :message to
+  def call(options)
+    message = build_message(options)
+    deliver_message(message, options)
+  end
+
+  # Responsible for building a :message from the various :contexts.
+  #
+  # @see .call
+  #
+  # @param [Hash] options
+  # @option options [Message] :message The message you want to amend.
+  #   If none is provided, then one is created.
+  # @option options [Object, Array<Object>] :contexts One or more Objects that
+  #   Harbinger will visit and extract message elements from.
+  def build_message(options = {})
+    contexts = Array(options.fetch(:contexts)).flatten.compact
+    message = options.fetch(:message) { default_message }
+
+    contexts.each { |context| reporter_for(context).accept(message) }
+    message
+  end
+
+  # Responsible for delivering a :message to the appropriate :channels.
+  #
+  # @see .call
+  #
+  # @param message [Message] The message you want to amend.
+  #   If none is provided, then one is created.
+  # @param [Hash] options
+  # @option options [Symbol, Array<Symbol>] :channels One or more channels that
+  #   Harbinger will deliver the :message to
+  def deliver_message(message, options = {})
+    channels = options.fetch(:channels) { default_channels }
+    Array(channels).flatten.compact.each do |channel_name|
+      channel = channel_for(channel_name)
+      channel.deliver(message)
+    end
+    true
+  end
+
+  def default_message
+    require 'harbinger/message'
+    Message.new
+  end
+  private_class_method :default_message
+
+  def reporter_for(context)
+    Reporters.find_for(context)
+  end
+  private_class_method :reporter_for
+
+  def channel_for(name)
+    Channels.find_for(name)
+  end
+  private_class_method :channel_for
+
+  def default_channels
+    configuration.default_channels
+  end
+
+  def logger
+    configuration.logger
+  end
+
+  def database_storage
+    configuration.database_storage
+  end
+
 end

data/lib/harbinger/channels.rb

@@ -0,0 +1,25 @@
+module Harbinger
+  module Channels
+    module_function
+    def find_for(channel_name)
+      channel_class_name = channel_name_for_instance(channel_name)
+      if const_defined?(channel_class_name)
+        const_get(channel_class_name)
+      else
+        NullChannel
+      end
+    rescue StandardError
+      NullChannel
+    end
+
+    def channel_name_for_instance(channel_name)
+      channel_name.to_s.gsub(/(?:^|_)([a-z])/) { $1.upcase } + "Channel"
+    end
+    private_class_method :channel_name_for_instance
+  end
+end
+
+# Note: I am not requiring all of the channels for this Gem. Some
+# implementations my want to override the defaults. Look to
+# `lib/harbinger/engine.rb` for how things are required for Rails applications.
+require 'harbinger/channels/null_channel'

data/lib/harbinger/channels/database_channel.rb

@@ -0,0 +1,15 @@
+module Harbinger::Channels
+  module DatabaseChannel
+    module_function
+    def deliver(message, options = {})
+      storage = options.fetch(:storage) { default_storage }
+      storage.store_message(message)
+    end
+
+    def default_storage
+      Harbinger.database_storage
+    end
+    private_class_method :default_storage
+
+  end
+end

data/lib/harbinger/channels/logger_channel.rb

@@ -0,0 +1,31 @@
+module Harbinger::Channels
+  module LoggerChannel
+    module_function
+    def deliver(message, options = {})
+      logger = options.fetch(:logger) { default_logger }
+      severity = options.fetch(:severity) { default_severity }
+      read(message) do |line|
+        logger.add(severity, line)
+      end
+    end
+
+    def read(message)
+      yield("BEGIN MESSAGE OBJECT ID=#{message.object_id}")
+      message.attributes.each do |key, value|
+        yield("#{key.inspect} => #{value.inspect}")
+      end
+      yield("END MESSAGE OBJECT ID=#{message.object_id}")
+    end
+    private_class_method :read
+
+    def default_logger
+      Harbinger.logger
+    end
+    private_class_method :default_logger
+
+    def default_severity
+      5 # ::Logger::UNKNOWN
+    end
+    private_class_method :default_severity
+  end
+end

data/lib/harbinger/channels/null_channel.rb

@@ -0,0 +1,7 @@
+module Harbinger::Channels
+  module NullChannel
+    module_function
+    def deliver(message, options = {})
+    end
+  end
+end

data/lib/harbinger/configuration.rb

@@ -0,0 +1,58 @@
+require 'harbinger/exceptions'
+module Harbinger
+  class Configuration
+
+    def default_channels
+      @default_channels || __default_channels
+    end
+
+    def default_channels=(*channel_names)
+      @default_channels = Array(channel_names).flatten.compact.collect{|name|
+        word = name.to_s
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word.to_sym
+      }
+    end
+
+    def logger
+      @logger || default_logger
+    end
+
+    def logger=(object)
+      raise ConfigurationError.new("Expected Harbinger.database_storage to respond_to #add. #{object.inspect} does not respond to #add") unless object.respond_to?(:add)
+      @logger = object
+    end
+
+    def database_storage
+      @database_storage || default_database_storage
+    end
+
+    def database_storage=(object)
+      raise ConfigurationError.new("Expected Harbinger.database_storage to respond_to #store_message. #{object.inspect} does not respond to #add") unless object.respond_to?(:store_message)
+      @database_storage = object
+    end
+
+    private
+
+    def default_logger
+      if defined?(Rails)
+        Rails.logger
+      else
+        require 'logger'
+        ::Logger.new(STDOUT)
+      end
+    end
+
+    def default_database_storage
+      require 'harbinger/database_channel_message'
+      DatabaseChannelMessage
+    end
+
+    def __default_channels
+      [:logger]
+    end
+  end
+end

data/lib/harbinger/engine.rb

@@ -1,5 +1,12 @@
 module Harbinger
   class Engine < ::Rails::Engine
-    isolate_namespace Harbinger
+    engine_name 'harbinger'
+
+    config.to_prepare do
+      # Because I don't want to auto-require all of the dependent channels
+      Harbinger.default_channels.each do |channel_name|
+        require "harbinger/channels/#{channel_name}_channel"
+      end
+    end
   end
 end

data/lib/harbinger/exceptions.rb

@@ -0,0 +1,4 @@
+module Harbinger
+  class ConfigurationError < RuntimeError
+  end
+end

data/lib/harbinger/message.rb

@@ -0,0 +1,20 @@
+module Harbinger
+  class Message
+    attr_reader :attributes
+    def initialize
+      @attributes = {}
+      yield(self) if block_given?
+    end
+
+    def append(container, key, value)
+      composite_key = "#{container}.#{key}"
+      @attributes[composite_key] ||= []
+      @attributes[composite_key] << value
+    end
+
+    def contexts
+      attributes.keys.collect { |key| key.split('.')[0] }.uniq
+    end
+
+  end
+end

data/lib/harbinger/reporters.rb

@@ -0,0 +1,34 @@
+module Harbinger
+  module Reporters
+    module_function
+    def find_for(context)
+      if context.respond_to?(:to_harbinger_reporter)
+        context.to_harbinger_reporter
+      else
+        # @TODO - Handle inheritence; KeyError is not an Exception
+        reporter_class_name = reporter_name_for_instance(context)
+        if const_defined?(reporter_class_name)
+          const_get(reporter_class_name).new(context)
+        else
+          NullReporter.new(context)
+        end
+      end
+    rescue StandardError
+      NullReporter.new(context)
+    end
+
+    def reporter_name_for_instance(context)
+      if context.is_a?(Exception)
+        "ExceptionReporter"
+      else
+        context.class.to_s.gsub(/(?:^|_)([a-z])/) { $1.upcase } + "Reporter"
+      end
+    end
+    private_class_method :reporter_name_for_instance
+  end
+end
+
+require "harbinger/reporters/user_reporter"
+require "harbinger/reporters/request_reporter"
+require "harbinger/reporters/exception_reporter"
+require "harbinger/reporters/null_reporter"

data/lib/harbinger/reporters/exception_reporter.rb

@@ -0,0 +1,26 @@
+module Harbinger::Reporters
+  class ExceptionReporter
+    attr_reader :exception
+
+    def initialize(exception)
+      @exception = exception
+    end
+
+    def accept(message)
+
+      if exception.respond_to?(:class)
+        message.append('exception', 'class_name', exception.class.to_s)
+      end
+
+      if exception.respond_to?(:backtrace)
+        message.append('exception', 'backtrace', Array(exception.backtrace).join("\n"))
+      end
+
+      if exception.respond_to?(:message)
+        message.append('exception', 'message', exception.message)
+      end
+
+    end
+
+  end
+end

data/lib/harbinger/reporters/null_reporter.rb

@@ -0,0 +1,14 @@
+module Harbinger::Reporters
+  class NullReporter
+    attr_reader :context
+
+    def initialize(context, config = {})
+      @context = context
+    end
+
+    def accept(message)
+      message.append('nil', context.class.to_s, context.inspect)
+    end
+
+  end
+end

data/lib/harbinger/reporters/request_reporter.rb

@@ -0,0 +1,20 @@
+module Harbinger
+  module Reporters
+    class RequestReporter
+      attr_reader :request, :method_names
+      private :method_names
+      def initialize(request, config = {})
+        @request = request
+        @method_names = config.fetch(:method_names) { ['path', 'params', 'user_agent'] }
+      end
+
+      def accept(message)
+        method_names.each do |method_name|
+          if request.respond_to?(method_name)
+            message.append('request', method_name, request.public_send(method_name))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/harbinger/reporters/user_reporter.rb

@@ -0,0 +1,20 @@
+module Harbinger::Reporters
+  class UserReporter
+    attr_reader :user, :method_names
+    private :method_names
+
+    def initialize(user, config = {})
+      @user = user
+      @method_names = config.fetch(:method_names) { ['username'] }
+    end
+
+    def accept(message)
+      method_names.each do |method_name|
+        if user.respond_to?(method_name)
+          message.append('user', method_name, user.public_send(method_name))
+        end
+      end
+    end
+
+  end
+end

data/lib/harbinger/version.rb

@@ -1,3 +1,3 @@
 module Harbinger
-  VERSION = "0.0.1.pre"
+  VERSION = "0.1.0"
 end

data/run_each_spec_in_isolation

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby -w
+require 'time'
+require 'rake'
+
+FileList['spec/**/*_spec.rb'].sort.select do |fn|
+  puts "rspec #{fn}"
+  system "rspec #{fn}"
+end
+system('rspec')

data/script/fast_specs

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby -w
+
+require 'rake'
+
+module Fast
+  module_function
+  def spec?(fn)
+    open(fn) { |f| f.gets =~ /fast_helper/ }
+  end
+end
+
+fast_specs = FileList['spec/**/*_spec.rb'].select { |fn|
+  Fast.spec?(fn)
+}
+if fast_specs.any?
+  system "rspec #{fast_specs}"
+else
+  puts "Unable to find any fast specs"
+  exit(-1)
+end