evenitron 0.1.0

data/README.markdown

@@ -0,0 +1,65 @@
+# Setting up with delayed_job
+
+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:
+
+```ruby
+require 'evenitron/delayed_job'
+
+Evenitron::DelayedJob.configure do
+  system_key 'benchmarking'
+  # collector_url 'http://localhost:5000/'
+end
+```
+
+Or you can rely on the environment variables `EVENITRON_SYSTEM_KEY` and `EVENITRON_COLLECTOR_URL`:
+
+```ruby
+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:
+
+```ruby
+require 'evenitron/resque'
+
+Evenitron::Resque.configure do
+  system_key 'benchmarking'
+  # collector_url 'http://localhost:5000/'
+end
+```
+
+Or you can rely on the environment variables `EVENITRON_SYSTEM_KEY` and `EVENITRON_COLLECTOR_URL`:
+
+```ruby
+require 'evenitron/resque'
+
+Evenitron::Resque.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/`.

data/lib/evenitron/collector_client.rb

@@ -0,0 +1,76 @@
+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
+      @user_agent = 'evenitron-ruby 0.1'
+      @user_agent = "#{@user_agent} (#{component})" if component
+      @simulate_requests = ENV['EVENITRON_SIMULATE_REQUESTS'] == 'true'
+      log.warn 'Simulating Evenitron messages' if @simulate_requests
+    end
+
+    def job_queued(args)
+      send_message :queued, args
+    end
+
+    def job_started(args)
+      send_message :started, args
+    end
+
+    def job_failed(args)
+      send_message :failed, args
+    end
+
+    def job_complete(args)
+      send_message :complete, args
+    end
+
+    private
+
+    def send_message(stage, args)
+      send message(stage, args)
+    end
+
+    def send(msg)
+      json = msg.to_json
+
+      if @simulate_requests
+        log.info "Simulating message for #{@system_key} to #{@url} - #{json}"
+        return nil
+      else
+        log.debug "Sending message for #{@system_key} to #{@url} - #{json}"
+      end
+
+      Thread.new do
+        begin
+          RestClient.post @url, json, :content_type => nil, 'Evenitron-Key' => @system_key, 'User-Agent' => @user_agent
+        rescue => e
+          log.error "Failed to send message for #{@system_key} to #{@url} - #{json}"
+          log.debug e
+        end
+      end
+
+      nil
+    end
+
+    def message(stage, args)
+      msg = args.dup
+      msg[:stage] = stage
+      msg[:version] = 1
+      msg[:timestamp] = since_epoch(Time.now)
+      msg
+    end
+
+    def since_epoch(time)
+      (time.to_f * 1000).to_i
+    end
+
+  end
+
+end

data/lib/evenitron/delayed_job.rb

@@ -0,0 +1,112 @@
+require_relative '../evenitron'
+require 'delayed_job'
+
+module Evenitron
+
+  module DelayedJob
+
+    def self.configure(&block)
+      dj = Evenitron::DelayedJobCollector.new
+      dj.configure &block unless block.nil?
+      dj.start!
+      nil
+    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
+      Delayed::Worker.lifecycle
+    end
+
+    def register_lifecycle_hooks
+      log.info "Registering delayed_job job queued callback"
+      lifecycle.around :enqueue do |job, &block|
+        result = block.call(job)
+        job_queued job
+        result
+      end
+
+      log.info "Registering delayed_job job failed callback"
+      lifecycle.before :failure do |worker, job|
+        job_failed job
+      end
+
+      log.info "Registering delayed_job job requeued callback"
+      lifecycle.after :error do |worker, job|
+        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"
+      lifecycle.around :perform do |worker, job, &block|
+        job_started job, worker
+        result = block.call(worker, job)
+        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
+
+  end
+
+end

data/lib/evenitron/evenitron.rb

@@ -0,0 +1,32 @@
+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

data/lib/evenitron/logger.rb

@@ -0,0 +1,11 @@
+module Evenitron
+
+  module Logger
+
+    def log
+      Evenitron.logger
+    end
+
+  end
+
+end

data/lib/evenitron/resque.rb

@@ -0,0 +1,149 @@
+require_relative '../evenitron'
+require 'resque'
+
+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
+
+    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']
+    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.rb

@@ -0,0 +1,12 @@
+require 'bundler/setup'
+require 'base64'
+require 'rest_client'
+require 'securerandom'
+require 'logger'
+require 'json'
+
+module Evenitron ; end
+
+require_relative 'evenitron/evenitron'
+require_relative 'evenitron/logger'
+require_relative 'evenitron/collector_client'

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: evenitron
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Evenitron
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-25 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: &70228307216040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+  type: :runtime
+  prerelease: false
+  version_requirements: *70228307216040
+description: Ruby client for Evenitron with hooks for delayed_job and resque
+email:
+- support@evenitron.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/evenitron/collector_client.rb
+- lib/evenitron/delayed_job.rb
+- lib/evenitron/evenitron.rb
+- lib/evenitron/logger.rb
+- lib/evenitron/resque.rb
+- lib/evenitron.rb
+- README.markdown
+homepage: https://github.com/evenitron/evenitron-ruby
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: evenitron-ruby
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Ruby client for Evenitron
+test_files: []
+has_rdoc: