evenitron 0.1.0 → 0.2.0

data/README.markdown

@@ -1,23 +1,28 @@
-# Setting up with delayed_job
+# Evenitron
 
-There are two options for setting up Evenitron to monitor your delayed_job tasks.
+Evenitron is a service to help you to properly understand the performance of your delayed_job and resque jobs.
+
+## Getting started
+
+In order to use the Evenitron service you will need a `system key` which is assigned to you when you sign up for an account. This key identifies you system to the Evenitron aggregators.
+
+If you don't have an account you can request an invite to our private beta program here : http://app.evenitron.com/invite_requests/new
 
 Firstly, add the gem to your Gemfile:
 
 ```ruby
-gem 'evenitron-ruby', :git => 'git@github.com:evenitron/evenitron-ruby.git'
+gem 'evenitron'
 ```
 
-*We'll use the git references if possible until things are public.*
+On start you need to configure the gem with your system key. In Rails this would go in `config\initializers\evenitron.rb`.
 
-Then you need to configure it within your `boot.rb` for Rails (I have no idea if this is the right file but it works). You can either do this explicitly:
+### delayed_job setup
 
 ```ruby
 require 'evenitron/delayed_job'
 
 Evenitron::DelayedJob.configure do
-  system_key 'benchmarking'
-  # collector_url 'http://localhost:5000/'
+  system_key 'your_key'
 end
 ```
 
@@ -29,28 +34,13 @@ require 'evenitron/delayed_job'
 Evenitron::DelayedJob.configure
 ```
 
-You must specify your system key either through configuration or the `EVENITRON_SYSTEM_KEY` environment variable but you will normally rely on the default collector URL of `https://collector.evenitron.com/`.
-
-# Setting up with resque
-
-There are two options for setting up Evenitron to monitor your delayed_job tasks.
-
-Firstly, add the gem to your Gemfile:
-
-```ruby
-gem 'evenitron-ruby', :git => 'git@github.com:evenitron/evenitron-ruby.git'
-```
-
-*We'll use the git references if possible until things are public.*
-
-Then you need to configure it within your `boot.rb` for Rails (I have no idea if this is the right file but it works). You can either do this explicitly:
+### resque setup
 
 ```ruby
 require 'evenitron/resque'
 
 Evenitron::Resque.configure do
-  system_key 'benchmarking'
-  # collector_url 'http://localhost:5000/'
+  system_key 'your_key'
 end
 ```
 
@@ -62,4 +52,6 @@ require 'evenitron/resque'
 Evenitron::Resque.configure
 ```
 
+## Notes
+
 You must specify your system key either through configuration or the `EVENITRON_SYSTEM_KEY` environment variable but you will normally rely on the default collector URL of `https://collector.evenitron.com/`.

data/lib/evenitron.rb

@@ -5,8 +5,117 @@ require 'securerandom'
 require 'logger'
 require 'json'
 
-module Evenitron ; end
+module Evenitron
+  require 'evenitron/logger'
+  require 'evenitron/collector_client'
+  require 'evenitron/collector'
+
+  # Public: convenience method for configuring the gem
+  #
+  # Examples
+  #
+  #   Evenitron.configure do |config|
+  #     config.system_key = 'your system key'
+  #   end
+  #
+  # Raises StandardError if no system_key passed or found in env variable
+  def self.configure
+    yield self if block_given?
+
+    logger.error "Evenitron system_key required" && return unless self.system_key
+
+    initialize_delayed_job if Evenitron.delayed_job_present?
+    initialize_resque if Evenitron.resque_present?
+
+    logger.info "Evenitron configured with #{self.system_key} #{self.collector_url}"
+  end
+
+  # Public: configured logger
+  #
+  def self.logger
+    @logger ||= default_logger
+  end
+
+  # Public: configured connection url for the gem to use
+  #
+  def self.collector_url
+    @collector_url ||= (ENV['EVENITRON_COLLECTOR_URL'] || "http://collector.evenitron.com")
+  end
+
+  # Public: configured system_key for the gem to use
+  #
+  def self.system_key
+    @system_key ||= ENV['EVENITRON_SYSTEM_KEY']
+  end
+
+  class << self
+    # Public: Writers for the config values
+    #
+    attr_writer :logger, :collector_url, :system_key
+  end
+
+  # Public: util method for encoding values for network transport.
+  #
+  # values      - Enumerable of Strings
+  #
+  # Returns clean, Base64 encoded String
+  def self.encode(*values)
+    value = values.join ':'
+    cleanse_base64 Base64.encode64(value)
+  end
+
+  # Public: generates a unique id fo a transaction
+  #
+  # length      - length of the key (default: 64)
+  #
+  # Returns String id
+  def self.generate_id(length = 64)
+    cleanse_base64 SecureRandom.base64(length)
+  end
+
+private
+
+  # Private: constructs a default STDOUT logger set to INFO
+  #
+  def self.default_logger
+    logger = ::Logger.new(STDOUT)
+    logger.level = ::Logger::INFO
+    logger
+  end
+
+  # Private: strips space and = from Base64 strings
+  #
+  # value     - String to cleanse
+  #
+  # Returns cleansed String
+  def self.cleanse_base64(value)
+    value.gsub /[\s=]/, ''
+  end
+
+
+  # Public: delayed_job present?
+  #
+  def self.delayed_job_present?
+    Module.const_defined? 'Delayed'
+  end
+
+  # Public: resque present?
+  #
+  def self.resque_present?
+    Module.const_defined? 'Resque'
+  end
+
+  def self.initialize_delayed_job
+    require 'evenitron/delayed_job'
+    Evenitron::DelayedJob.register_lifecycle_hooks
+    logger.info "Configured Evenitron delayed_job hooks"
+  end
+
+  def self.initialize_resque
+    require 'evenitron/resque'
+    logger.info "Configured Evenitron resque hooks"
+  end
+
+end
+
 
-require_relative 'evenitron/evenitron'
-require_relative 'evenitron/logger'
-require_relative 'evenitron/collector_client'

data/lib/evenitron/collector.rb

@@ -0,0 +1,14 @@
+# Public: common methods for collectors
+module Evenitron
+
+  module Collector
+
+    # Public: lazy load client with the configured values
+    # Expects the host method to expose a component method
+    def client
+      @_client ||= CollectorClient.new Evenitron.system_key, Evenitron.collector_url, component
+    end
+
+  end
+
+end

data/lib/evenitron/collector_client.rb

@@ -1,14 +1,21 @@
+# Public: Handles communication with the Evenitron collector
+#
 module Evenitron
 
   class CollectorClient
 
     include Evenitron::Logger
 
-    DEFAULT_URL = "https://collector.evenitron.com/"
-
-    def initialize(system_key, url = DEFAULT_URL, component = nil)
-      @system_key = system_key
-      @url = url
+    # Public: constructor
+    #
+    # system_key    - String key identifying the system
+    # url           - String url of the collector to push messages to
+    # component     - optional String identifying the component generating the message,
+    #                 Used to construct UserAgent for requests
+    #
+    # Returns a new instance of CollectorClient
+    def initialize(system_key, url, component = nil)
+      @system_key, @url = system_key, url
       @user_agent = 'evenitron-ruby 0.1'
       @user_agent = "#{@user_agent} (#{component})" if component
       @simulate_requests = ENV['EVENITRON_SIMULATE_REQUESTS'] == 'true'
@@ -37,6 +44,11 @@ module Evenitron
       send message(stage, args)
     end
 
+    # Private: sends the messages to the collector
+    #
+    # msg       - Hash comprising all args to send
+    #
+    # Returns nothing
     def send(msg)
       json = msg.to_json
 
@@ -59,6 +71,13 @@ module Evenitron
       nil
     end
 
+    # Private: construct a hahs comprising the message elements by combining
+    # the optional args, stage, version and timestamp
+    #
+    # stage     - Symbol or String indicating the stage of the transaction
+    # args      - Hash of additional arguments to send
+    #
+    # Returns Hash
     def message(stage, args)
       msg = args.dup
       msg[:stage] = stage

data/lib/evenitron/delayed_job.rb

@@ -1,112 +1,53 @@
-require_relative '../evenitron'
 require 'delayed_job'
+require_relative 'delayed_job/collector'
 
 module Evenitron
 
   module DelayedJob
 
-    def self.configure(&block)
-      dj = Evenitron::DelayedJobCollector.new
-      dj.configure &block unless block.nil?
-      dj.start!
-      nil
+    # Public: lazy load DelayedJob specific collector
+    #
+    def self.collector
+      @_collector ||= Evenitron::DelayedJob::Collector.new
     end
 
-  end
-
-  class DelayedJobCollector
-
-    include Evenitron::Logger
-
-    def initialize
-      @collector_url = ENV['EVENITRON_COLLECTOR_URL']
-      @system_key = ENV['EVENITRON_SYSTEM_KEY']
-    end
-
-    def configure(&block)
-      instance_eval &block
-    end
-
-    def system_key(key)
-      @system_key = key
-    end
-
-    def api_key(key)
-      @api_key = key
-    end
-
-    def collector_url(url)
-      @collector_url = url
-    end
-
-    def start!
-      log.info "Registering delayed_job evenitron collector with system key #{@system_key} to send messages to #{@collector_url}"
-      @client = Evenitron::CollectorClient.new @system_key, @collector_url, 'dj'
-      register_lifecycle_hooks
-    end
-
-    private
-
-    def lifecycle
+    def self.lifecycle
       Delayed::Worker.lifecycle
     end
 
-    def register_lifecycle_hooks
-      log.info "Registering delayed_job job queued callback"
+    # Public: wire up DelayedJob with hooks for generating collector messages
+    #
+    def self.register_lifecycle_hooks
+      Evenitron.logger.info "Registering delayed_job job queued callback"
       lifecycle.around :enqueue do |job, &block|
         result = block.call(job)
-        job_queued job
+        Evenitron::DelayedJob.collector.job_queued job
         result
       end
 
-      log.info "Registering delayed_job job failed callback"
+      Evenitron.logger.info "Registering delayed_job job failed callback"
       lifecycle.before :failure do |worker, job|
-        job_failed job
+        Evenitron::DelayedJob.collector.job_failed job
       end
 
-      log.info "Registering delayed_job job requeued callback"
+      Evenitron.logger.info "Registering delayed_job job requeued callback"
       lifecycle.after :error do |worker, job|
-        job_queued job unless job.failed? or job.frozen?
+        Evenitron::DelayedJob.collector.job_queued job unless job.failed? or job.frozen?
       end
 
-      log.info "Registering delayed_job job started callback"
-      log.info "Registering delayed_job job complete callback"
+      Evenitron.logger.info "Registering delayed_job job started callback"
+      Evenitron.logger.info "Registering delayed_job job complete callback"
       lifecycle.around :perform do |worker, job, &block|
-        job_started job, worker
+        Evenitron::DelayedJob.collector.job_started job, worker
         result = block.call(worker, job)
-        job_complete job if result
+        Evenitron::DelayedJob.collector.job_complete job if result
         result
       end
-    end
 
-    def job_queued(job)
-      id = get_id(job)
-      log.info "Sending job queued message for job #{job.id} (evenitron id #{id})"
-      @client.job_queued :id => id, :queue => job.class.table_name, :task => job.name
     end
-
-    def job_started(job, worker)
-      id = get_id(job)
-      log.info "Sending job started message for job #{job.id} (evenitron id #{id})"
-      @client.job_started :id => id, :worker => worker.name, :task => job.name
-    end
-
-    def job_failed(job)
-      id = get_id(job)
-      log.info "Sending job failed message for job #{job.id} (evenitron id #{id})"
-      @client.job_failed :id => id, :task => job.name
-    end
-
-    def job_complete(job)
-      id = get_id(job)
-      log.info "Sending job complete message for job #{job.id} (evenitron id #{id})"
-      @client.job_complete :id => id, :task => job.name
-    end
-
-    def get_id(job)
-      Evenitron.encode job.class.table_name, job.id
-    end
-
+    
+    register_lifecycle_hooks if Evenitron.delayed_job_enabled?
+    
   end
 
 end

data/lib/evenitron/delayed_job/collector.rb

@@ -0,0 +1,37 @@
+module Evenitron
+
+  module DelayedJob
+
+    class Collector
+
+      include Evenitron::Collector
+
+      def component
+        "dj"
+      end
+
+      def job_queued(job)
+        client.job_queued :id => get_id(job), :queue => job.class.table_name, :task => job.name
+      end
+
+      def job_started(job, worker)
+        client.job_started :id => get_id(job), :worker => worker.name, :task => job.name
+      end
+
+      def job_failed(job)
+        client.job_failed :id => get_id(job), :task => job.name
+      end
+
+      def job_complete(job)
+        client.job_complete :id => get_id(job), :task => job.name
+      end
+
+      def get_id(job)
+        Evenitron.encode job.class.table_name, job.id
+      end
+
+    end
+
+  end
+
+end

data/lib/evenitron/resque.rb

@@ -1,149 +1,19 @@
-require_relative '../evenitron'
+# Public: coordinates loading of hooks for resque monitoring
+#
 require 'resque'
+require_relative 'resque/resque'
+require_relative 'resque/collector'
 
 module Evenitron
 
-  class NullResqueCollector
-
-    include Evenitron::Logger
-
-    def job_queued(queue, item)
-      log.warn "EVENITRON NOT CONFIGURED : Not sending job queued message for job #{item['evenitron_id']}"
-    end
-
-    def job_started(job)
-      log.info "EVENITRON NOT CONFIGURED : Not sending job started message for job #{job.evenitron_id}"
-    end
-
-    def job_failed(job)
-      log.info "EVENITRON NOT CONFIGURED : Not sending job failed message for job #{job.evenitron_id}"
-    end
-
-    def job_complete(job)
-      log.info "EVENITRON NOT CONFIGURED : Not sending job complete message for job #{job.evenitron_id}"
-    end
-
-  end
-
   module Resque
 
-    @@collector = Evenitron::NullResqueCollector.new
-
-    def self.configure(&block)
-      rc = Evenitron::ResqueCollector.new
-      rc.configure &block unless block.nil?
-      rc.start!
-      @@collector = rc
-      nil
-    end
-
+    # Public: lazy load resque specific collector
+    #
     def self.collector
-      @@collector
-    end
-
-  end
-
-  class ResqueCollector
-
-    include Evenitron::Logger
-
-    def initialize
-      @collector_url = ENV['EVENITRON_COLLECTOR_URL']
-      @system_key = ENV['EVENITRON_SYSTEM_KEY']
-    end
-
-    def configure(&block)
-      instance_eval &block
-    end
-
-    def system_key(key)
-      @system_key = key
-    end
-
-    def api_key(key)
-      @api_key = key
-    end
-
-    def collector_url(url)
-      @collector_url = url
-    end
-
-    def start!
-      log.info "Registering resque evenitron collector with system key #{@system_key} to send messages to #{@collector_url}"
-      @client = Evenitron::CollectorClient.new @system_key, @collector_url, 'resque'
-    end
-
-    def job_queued(queue, item)
-      id = get_id(item)
-      log.info "Sending job queued message for job #{id}"
-      @client.job_queued :id => id, :queue => queue, :task => item[:class]
-    end
-
-    def job_started(job)
-      log.info "Sending job started message for job #{job.evenitron_id}"
-      @client.job_started :id => job.evenitron_id, :worker => job.worker.to_s, :task => job.payload['class']
-    end
-
-    def job_failed(job)
-      log.info "Sending job failed message for job #{job.evenitron_id}"
-      @client.job_failed :id => job.evenitron_id, :task => job.payload['class']
-    end
-
-    def job_complete(job)
-      log.info "Sending job complete message for job #{job.evenitron_id}"
-      @client.job_complete :id => job.evenitron_id, :task => job.payload['class']
-    end
-
-    private
-
-    def get_id(item)
-      item['evenitron_id']
+      @_collector ||= Evenitron::Resque::Collector.new
     end
 
   end
 
 end
-
-module Resque
-
-  class << self
-
-    alias :base_push :push
-
-    def push(queue, item)
-      item['evenitron_id'] ||= Evenitron.generate_id
-      base_push(queue, item)
-      Evenitron::Resque.collector.job_queued queue, item
-    end
-
-  end
-
-  class Job
-
-    alias :base_perform :perform
-
-    def perform
-      begin
-        Evenitron.logger.debug "Processing job #{evenitron_id}"
-        Evenitron::Resque.collector.job_started self
-
-        result = base_perform
-        Evenitron::Resque.collector.job_complete self
-
-        Evenitron.logger.debug "Processed job #{evenitron_id}, result was #{result}"
-        result
-      rescue => e
-        Evenitron.logger.fatal "Exception occurred whilst processing job #{evenitron_id}"
-        Evenitron.logger.debug e.inspect
-        Evenitron::Resque.collector.job_failed self
-        raise e
-      end
-    end
-
-    def evenitron_id
-      @payload['evenitron_id']
-    end
-
-  end
-
-end

data/lib/evenitron/resque/collector.rb

@@ -0,0 +1,39 @@
+module Evenitron
+
+  module Resque
+
+    class Collector
+
+      include Evenitron::Collector
+
+      def component
+        "resque"
+      end
+
+      def job_queued(queue, item)
+        client.job_queued :id => get_id(item), :queue => queue, :task => item[:class]
+      end
+
+      def job_started(job)
+        client.job_started :id => job.evenitron_id, :worker => job.worker.to_s, :task => job.payload['class']
+      end
+
+      def job_failed(job)
+        client.job_failed :id => job.evenitron_id, :task => job.payload['class']
+      end
+
+      def job_complete(job)
+        client.job_complete :id => job.evenitron_id, :task => job.payload['class']
+      end
+
+      private
+
+      def get_id(item)
+        item['evenitron_id']
+      end
+
+    end
+
+  end
+
+end

data/lib/evenitron/resque/resque.rb

@@ -0,0 +1,52 @@
+# Public: Wraps resque methods and classes with hooks to generate messages
+# to the collector
+#
+module Resque
+
+  class << self
+
+    alias :base_push :push
+
+    # Private: wraps the push method to decorate the job with an evenitron
+    # task id. Then generates a job queued message
+    def push(queue, item)
+      item['evenitron_id'] ||= Evenitron.generate_id
+      base_push(queue, item)
+      Evenitron::Resque.collector.job_queued queue, item
+    end
+    Evenitron.logger.info "Registered resque job queued callback"
+
+  end
+
+  class Job
+
+    alias :base_perform :perform
+
+    # Private: wraps the perform method to generate job processing messages
+    #
+    def perform
+      begin
+        Evenitron::Resque.collector.job_started self
+
+        result = base_perform
+        Evenitron::Resque.collector.job_complete self
+        result
+      rescue => e
+        Evenitron.logger.error "Exception occurred whilst processing job #{evenitron_id}"
+        Evenitron.logger.debug e.inspect
+        Evenitron::Resque.collector.job_failed self
+        raise e
+      end
+    end
+
+    Evenitron.logger.info "Registered resque job started callback"
+    Evenitron.logger.info "Registered resque job completed callback"
+    Evenitron.logger.info "Registered resque job failed callback"
+
+    def evenitron_id
+      @payload['evenitron_id']
+    end
+
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: evenitron
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-25 00:00:00.000000000Z
+date: 2012-06-17 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
-  requirement: &70228307216040 !ruby/object:Gem::Requirement
+  requirement: &70299044095340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: 1.6.7
   type: :runtime
   prerelease: false
-  version_requirements: *70228307216040
+  version_requirements: *70299044095340
 description: Ruby client for Evenitron with hooks for delayed_job and resque
 email:
 - support@evenitron.com
@@ -29,10 +29,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/evenitron/collector.rb
 - lib/evenitron/collector_client.rb
+- lib/evenitron/delayed_job/collector.rb
 - lib/evenitron/delayed_job.rb
-- lib/evenitron/evenitron.rb
 - lib/evenitron/logger.rb
+- lib/evenitron/resque/collector.rb
+- lib/evenitron/resque/resque.rb
 - lib/evenitron/resque.rb
 - lib/evenitron.rb
 - README.markdown

data/lib/evenitron/evenitron.rb

@@ -1,32 +0,0 @@
-module Evenitron
-
-  def self.logger
-    @@logger ||= default_logger
-  end
-
-  def self.logger=(logger)
-    @@logger = logger
-  end
-
-  def self.encode(*values)
-    value = values.join ':'
-    cleanse_base64 Base64.encode64(value)
-  end
-
-  def self.generate_id(length = 64)
-    cleanse_base64 SecureRandom.base64(length)
-  end
-
-  private
-
-  def self.default_logger
-    logger = ::Logger.new(STDOUT)
-    logger.level = ::Logger::INFO
-    logger
-  end
-
-  def self.cleanse_base64(value)
-    value.gsub /[\s=]/, ''
-  end
-
-end