workerholic 0.0.14 → 0.0.15

data/lib/workerholic/statistics_storage.rb

@@ -8,6 +8,17 @@ module Workerholic
       storage.push(namespace, serialized_job_stats)
     end
 
+    def self.save_processes_memory_usage
+      PIDS.each do |pid|
+        size = `ps -p #{Process.pid} -o pid=,rss=`.scan(/\d+/).last
+        storage.hash_set('workerholic:stats:memory:processes', pid, size)
+      end
+    end
+
+    def self.delete_memory_stats
+      storage.delete('workerholic:stats:memory:processes')
+    end
+
     class << self
       private
 

data/lib/workerholic/storage.rb

@@ -13,6 +13,18 @@ module Workerholic
         end
       end
 
+      def hash_set(key, field, value, retry_delay = 5)
+        execute(retry_delay) { |conn| conn.hset(key, field, value) }
+      end
+
+      def hash_get(key, field, retry_delay = 5)
+        execute(retry_delay) { |conn| conn.hget(key, field) }
+      end
+
+      def delete(key, retry_delay = 5)
+        execute(retry_delay) { |conn| conn.del(key) }
+      end
+
       def list_length(key, retry_delay = 5)
         execute(retry_delay) { |conn| conn.llen(key) }
       end
@@ -42,6 +54,14 @@ module Workerholic
         execute(retry_delay) { |conn| conn.zcount(key, 0, '+inf') }
       end
 
+      def sorted_set_members(key, retry_delay = 5)
+        execute(retry_delay) { |conn| conn.zrange(key, 0, -1) }
+      end
+
+      def sorted_set_members_count(key, retry_delay = 5)
+        execute(retry_delay) { |conn| conn.zcard(key) }
+      end
+
       def keys_count(namespace, retry_delay = 5)
         execute(retry_delay) { |conn| conn.keys(namespace + ':*').size }
       end
@@ -52,25 +72,24 @@ module Workerholic
         execute(retry_delay) { |conn| conn.scan(0, match: queue_name_pattern).last }
       end
 
-      def available_keys(retry_delay = 5)
-        execute(retry_delay) { |conn| conn.keys('workerholic:stats:*') }
+      def get_keys_for_namespace(namespace, retry_delay = 5)
+        execute(retry_delay) { |conn| conn.keys(namespace) }
       end
 
-      def keys_for_namespace(namespace, retry_delay = 5)
-        execute(retry_delay) { |conn| conn.keys('workerholic:stats:' + namespace + ':*') }
+      def get_all_elements_from_list(key, retry_delay = 5)
+        execute(retry_delay) { |conn| conn.lrange(key, 0, -1) }
       end
 
-      def peek_namespace(key, retry_delay = 5)
-        execute(retry_delay) { |conn| conn.lrange(key, 0, -1) }
+      def hash_get(key, field, retry_delay = 5)
+        execute(retry_delay) { |conn| conn.hget(key, field) }
       end
 
-      def peek_namespaces(keys, retry_delay = 5)
-        execute(retry_delay) do |conn|
-          keys.select do |namespace|
-            full_namespace = 'workerholic:stats:' + namespace
-            conn.keys(full_namespace + ':*').size > 0
-          end
-        end
+      def hash_get_all(key, retry_delay = 5)
+        execute(retry_delay) { |conn| conn.hgetall(key) }
+      end
+
+      def hash_keys(namespace, retry_delay = 5)
+        execute(retry_delay) { |conn| conn.hkeys(namespace) }
       end
 
       class RedisCannotRecover < Redis::CannotConnectError; end

data/lib/workerholic/version.rb

@@ -1,3 +1,3 @@
 module Workerholic
-  VERSION = '0.0.14'
+  VERSION = '0.0.15'
 end

data/spec/helpers/helper_methods.rb

@@ -3,6 +3,7 @@ ANOTHER_TEST_QUEUE = 'workerholic:testing:queue:another_test_queue'
 BALANCER_TEST_QUEUE = 'workerholic:testing:queue:balancer_test_queue'
 ANOTHER_BALANCER_TEST_QUEUE = 'workerholic:testing:queue:another_balancer_test_queue'
 TEST_SCHEDULED_SORTED_SET = 'workerholic:testing:scheduled_jobs'
+HASH_TEST = 'workerholic:testing:hash_test'
 
 def expect_during(duration_in_secs, target)
   timeout = Time.now.to_f + duration_in_secs

data/spec/helpers/job_tests.rb

@@ -20,7 +20,7 @@ class FirstJobBalancerTest
   include Workerholic::Job
   job_options queue_name: BALANCER_TEST_QUEUE
 
-  def perform(str, num)
+  def perform(str, n)
     str
   end
 end
@@ -29,8 +29,15 @@ class SecondJobBalancerTest
   include Workerholic::Job
   job_options queue_name: ANOTHER_BALANCER_TEST_QUEUE
 
-  def perform(str, num)
+  def perform(str, n)
     str
   end
 end
 
+class DelayedJobTest
+  include Workerholic::Job
+
+  def perform(str)
+    str
+  end
+end

data/spec/integration/enqueuing_jobs_spec.rb

@@ -31,6 +31,17 @@ describe 'enqueuing jobs to Redis' do
       expect(job_from_redis.to_hash).to eq(expected_job.to_hash)
     end
 
+    xit 'enqueues a delayed job in redis' do
+      DelayedJobTest.new.perform_delayed(100, 'test job')
+      serialized_job = redis.lpop(TEST_QUEUE)
+      job_from_redis = Workerholic::JobSerializer.deserialize(serialized_job)
+
+      expected_job = Workerholic::JobWrapper.new(klass: SimpleJobTest, arguments: ['test job'], wrapper: SimpleJobTest)
+      expected_job.statistics.enqueued_at = job_from_redis.statistics.enqueued_at
+
+      expect(job_from_redis.to_hash).to eq(expected_job.to_hash)
+    end
+
     it 'enqueues a job with the right statistics' do
       SimpleJobTest.new.perform_async('test_job')
       serialized_job = redis.lpop(TEST_QUEUE)
@@ -50,5 +61,11 @@ describe 'enqueuing jobs to Redis' do
     it 'raises an error when wrong number of arguments is specified to perform_async' do
       expect { SimpleJobTest.new.perform_async(1, 2, 3) }.to raise_error(ArgumentError)
     end
+
+    it 'raises an ArgumentError if perform_delayed first argument is not of Numeric type' do
+      job = DelayedJobTest.new
+
+      expect { job.perform_delayed('wrong type', 'test arg') }.to raise_error(ArgumentError)
+    end
   end
 end

data/spec/job_processor_spec.rb

@@ -2,7 +2,6 @@ require_relative 'spec_helper'
 
 class SimpleJobTestWithError
   include Workerholic::Job
-  job_options queue_name: TEST_SCHEDULED_SORTED_SET
 
   def perform
     raise Exception
@@ -34,13 +33,14 @@ describe Workerholic::JobProcessor do
   end
 
   it 'does not raise an error when processing a job with error' do
-    serialized_job = Workerholic::JobSerializer.serialize({
-                       klass: SimpleJobTestWithError,
-                       arguments: [],
-                       statistics: Workerholic::JobStatistics.new.to_hash
-                     })
+    serialized_job = Workerholic::JobSerializer.serialize(
+      klass: SimpleJobTestWithError,
+      arguments: [],
+      statistics: Workerholic::JobStatistics.new.to_hash
+    )
 
     job_processor = Workerholic::JobProcessor.new(serialized_job)
+    allow(job_processor).to receive(:retry_job)
 
     expect { job_processor.process }.not_to raise_error
   end
@@ -52,10 +52,10 @@ describe Workerholic::JobProcessor do
       statistics: Workerholic::JobStatistics.new.to_hash
     }
     serialized_job = Workerholic::JobSerializer.serialize(job)
+    job_processor = Workerholic::JobProcessor.new(serialized_job)
 
-    allow(Workerholic::JobRetry).to receive(:new)
-    expect(Workerholic::JobRetry).to receive(:new)
+    expect(job_processor).to receive(:retry_job)
 
-    Workerholic::JobProcessor.new(serialized_job).process
+    job_processor.process
   end
 end

data/spec/job_retry_spec.rb

@@ -15,7 +15,7 @@ describe Workerholic::JobRetry do
     Workerholic::JobRetry.new(
       job: job,
       sorted_set: Workerholic::SortedSet.new(TEST_SCHEDULED_SORTED_SET)
-    )
+    ).retry
 
     expect(job.retry_count).to eq(1)
   end
@@ -26,7 +26,7 @@ describe Workerholic::JobRetry do
     Workerholic::JobRetry.new(
       job: job,
       sorted_set: Workerholic::SortedSet.new(TEST_SCHEDULED_SORTED_SET)
-    )
+    ).retry
 
     expect((job.execute_at - Time.now.to_f).ceil).to eq(30)
   end
@@ -37,7 +37,7 @@ describe Workerholic::JobRetry do
     Workerholic::JobRetry.new(
       job: job,
       sorted_set: Workerholic::SortedSet.new(TEST_SCHEDULED_SORTED_SET)
-    )
+    ).retry
 
     serialized_job = Workerholic::JobSerializer.serialize(job)
 
@@ -50,7 +50,7 @@ describe Workerholic::JobRetry do
     Workerholic::JobRetry.new(
       job: job,
       sorted_set: Workerholic::SortedSet.new(TEST_SCHEDULED_SORTED_SET)
-    )
+    ).retry
 
     expect(redis.exists(TEST_SCHEDULED_SORTED_SET)).to eq(false)
   end

data/spec/job_scheduler_spec.rb

@@ -1,16 +1,13 @@
 require_relative 'spec_helper'
 
-class SimpleDelayedJobTest
-  include Workerholic::Job
-  job_options queue_name: TEST_SCHEDULED_SORTED_SET
-
-  def perform(n, s)
-    s
+describe Workerholic::JobScheduler do
+  let(:scheduler) do
+    Workerholic::JobScheduler.new(
+      sorted_set: Workerholic::SortedSet.new(TEST_SCHEDULED_SORTED_SET),
+      queue_name: TEST_QUEUE
+    )
   end
-end
 
-describe Workerholic::JobScheduler do
-  let(:scheduler) { Workerholic::JobScheduler.new(set_name: TEST_SCHEDULED_SORTED_SET, queue_name: TEST_QUEUE) }
   let(:redis) { Redis.new }
 
   context 'with non-empty set' do
@@ -47,18 +44,4 @@ describe Workerholic::JobScheduler do
       expect(scheduler.queue.dequeue).to eq(serialized_job)
     end
   end
-
-  context 'with delayed job option specified' do
-    it 'adds delayed job to the scheduled sorted set' do
-      SimpleDelayedJobTest.new.perform_delayed(2, 'test arg')
-
-      expect(scheduler.sorted_set.empty?).to eq(false)
-    end
-
-    it 'raises an ArgumentError if perform_delayed first argument is not of Numeric type' do
-      job = SimpleDelayedJobTest.new
-
-      expect { job.perform_delayed("wrong type", 'test arg') }.to raise_error(ArgumentError)
-    end
-  end
 end

data/spec/spec_helper.rb

@@ -20,6 +20,10 @@ RSpec.configure do |config|
   config.shared_context_metadata_behavior = :apply_to_host_groups
 
   config.before do
-    Redis.new.del(TEST_QUEUE, ANOTHER_TEST_QUEUE, BALANCER_TEST_QUEUE, ANOTHER_BALANCER_TEST_QUEUE, TEST_SCHEDULED_SORTED_SET)
+    Redis.new.del(TEST_QUEUE, ANOTHER_TEST_QUEUE, BALANCER_TEST_QUEUE, ANOTHER_BALANCER_TEST_QUEUE, TEST_SCHEDULED_SORTED_SET, HASH_TEST)
+  end
+
+  config.after do
+    Redis.new.del(TEST_QUEUE, ANOTHER_TEST_QUEUE, BALANCER_TEST_QUEUE, ANOTHER_BALANCER_TEST_QUEUE, TEST_SCHEDULED_SORTED_SET, HASH_TEST)
   end
 end

data/spec/storage_spec.rb

@@ -68,6 +68,25 @@ describe Workerholic::Storage do
 
       expect(storage.fetch_queue_names).to match_array([queue_name, ANOTHER_TEST_QUEUE])
     end
+
+    it 'sets k and a value to a hash in redis' do
+      storage.hash_set(HASH_TEST, 'key_test', 1234)
+
+      expect(redis.hget(HASH_TEST, 'key_test')).to eq('1234')
+    end
+
+    it 'gets the value for a given key of a hash in redis' do
+      redis.hset(HASH_TEST, 'key_test', 1234)
+
+      expect(storage.hash_get(HASH_TEST, 'key_test')).to eq('1234')
+    end
+
+    it 'deletes a key from redis' do
+      redis.set(TEST_QUEUE, 'something')
+      storage.delete(TEST_QUEUE)
+
+      expect(redis.exists(TEST_QUEUE)).to eq(false)
+    end
   end
 
   context 'with Redis not running' do

data/spec/worker_balancer_spec.rb

@@ -16,8 +16,8 @@ describe Workerholic::WorkerBalancer do
   it 'fetches queues' do
     allow(Workerholic::WorkerBalancer.new).to receive(:fetch_queues).and_return(TESTED_QUEUES)
 
-    manager = Workerholic::WorkerBalancer.new(workers: [])
+    balancer = Workerholic::WorkerBalancer.new(workers: [])
 
-    expect(manager.queues.map(&:name)).to match_array(TESTED_QUEUES)
+    expect(balancer.queues.map(&:name)).to match_array(TESTED_QUEUES)
   end
 end

data/web/application.rb

@@ -11,12 +11,12 @@ class WorkerholicWeb < Sinatra::Base
   end
 
   get '/overview' do
-    erb :index
+    erb :overview
   end
 
   get '/details' do
-    completed_jobs = Workerholic::StatsAPI.job_statistics( {category: 'completed_jobs', count_only: true} )
-    failed_jobs = Workerholic::StatsAPI.job_statistics( {category: 'failed_jobs', count_only: true} )
+    completed_jobs = Workerholic::StatsAPI.job_statistics(category: 'completed_jobs', count_only: true)
+    failed_jobs = Workerholic::StatsAPI.job_statistics(category: 'failed_jobs', count_only: true)
 
     @job_stats = {}
     @completed_total = 0
@@ -28,7 +28,11 @@ class WorkerholicWeb < Sinatra::Base
     end
 
     failed_jobs.each do |job|
-      @job_stats[job[0]].merge( { failed: job[1] })
+      if @job_stats[job[0]]
+        @job_stats[job[0]].merge({ failed: job[1] })
+      else
+        @job_stats[job[0]] = { failed: job[1] }
+      end
       @failed_total += job[1]
     end
 
@@ -45,37 +49,27 @@ class WorkerholicWeb < Sinatra::Base
     erb :queues
   end
 
-  # get '/workers' do
-  #   erb :workers
-  # end
-  #
-  # get '/failed' do
-  #   erb :failed
-  # end
-  #
-  # get '/scheduled' do
-  #   erb :scheduled
-  # end
-
   get '/overview-data' do
     JSON.generate({
       completed_jobs: Workerholic::StatsAPI.job_statistics( {category: 'completed_jobs', count_only: true} ),
       failed_jobs: Workerholic::StatsAPI.job_statistics( {category: 'failed_jobs', count_only: true} ),
       queued_jobs: Workerholic::StatsAPI.queued_jobs,
-      workers_count: Workerholic.workers_count
+      workers_count: Workerholic.workers_count,
+      # memory_usage: Workerholic::StatsAPI.memory_usage
     })
   end
 
-  get '/detail-data' do
+  get '/details-data' do
     JSON.generate({
       completed_jobs: Workerholic::StatsAPI.job_statistics( {category: 'completed_jobs', count_only: true} ),
       failed_jobs: Workerholic::StatsAPI.job_statistics( {category: 'failed_jobs', count_only: true} )
     })
   end
 
-  get '/queue-data' do
+  get '/queues-data' do
     JSON.generate({
       queued_jobs: Workerholic::StatsAPI.queued_jobs
     })
   end
+
 end

data/web/public/javascripts/application.js

@@ -1,270 +1,316 @@
-var queuedJobsCountHistory = [];
-var failedJobsCountHistory = [];
-var jobsCompletedHistory = [];
+var App = {
+  queuedJobsCountHistory: [],
+  failedJobsCountHistory: [],
+  jobsCompletedHistory: [],
+  totalMemoryHistory: [],
+  tab: null,
+  getOverviewData: function() {
+    $.ajax({
+      url: '/overview-data',
+      context: this,
+      success: function(data) {
+        var deserializedData = JSON.parse(data);
 
-$(document).ready(function() {
-  var tab = $(location).attr('href').split('/').pop();
-  var $active = $('a[href=' + tab + ']');
+        var completedJobs = deserializedData.completed_jobs.reduce(function(sum, subArray) {
+          return sum + subArray[1];
+        }, 0);
 
-  $active.css('background', '#a2a2a2');
-  $active.css('color', '#fff');
+        var failedJobsCount= deserializedData.failed_jobs.reduce(function(sum, subArray) {
+          return sum + subArray[1];
+        }, 0);
 
-  if (tab === 'overview') {
-    getOverviewData();
+        var queuedJobs = deserializedData.queued_jobs;
 
-    setInterval(function() {
-      getOverviewData();
-    }, 5000);
-  }
-
-  if (tab === 'queues') {
-    setInterval(function() {
-      getQueueData();
-    }, 5000);
-  }
+        var queuedJobsCount = queuedJobs.reduce(function(sum, queue) {
+          return sum + queue[1];
+        }, 0);
 
-  if (tab === 'details') {
-    setInterval(function() {
-      getDetailData();
-    }, 1000);
-  }
-});
+        // var totalMemory = deserializedData.memory_usage ...
 
-function getOverviewData() {
-  $.ajax({
-    url: '/overview-data',
-    success: function(data) {
-      var deserializedData = JSON.parse(data);
+        this.queuedJobsCountHistory.unshift(queuedJobsCount);
+        this.failedJobsCountHistory.unshift(failedJobsCount);
+        this.jobsCompletedHistory.unshift(completedJobs);
+        // totalMemoryHistory.unshift(totalMemory); Waiting for data
 
-      var completedJobs = deserializedData.completed_jobs.reduce(function(sum, subArray) {
-        return sum + subArray[1];
-      }, 0);
+        if (this.queuedJobsCountHistory.length > 13) {
+          this.queuedJobsCountHistory.pop();
+          this.failedJobsCountHistory.pop();
+          this.jobsCompletedHistory.pop();
+          this.totalMemoryHistory.pop();
+        }
 
-      var failedJobsCount= deserializedData.failed_jobs.reduce(function(sum, subArray) {
-        return sum + subArray[1];
-      }, 0);
+        this.drawChart();
 
-      var queuedJobs = deserializedData.queued_jobs;
+        var workersCount = deserializedData.workers_count;
 
-      var queuedJobsCount = queuedJobs.reduce(function(sum, queue) {
-        return sum + queue[1];
-      }, 0);
-
-      queuedJobsCountHistory.unshift(queuedJobsCount);
-      failedJobsCountHistory.unshift(failedJobsCount);
-      jobsCompletedHistory.unshift(completedJobs);
-
-      if (queuedJobsCountHistory.length > 13) {
-        queuedJobsCountHistory.pop();
-        failedJobsCountHistory.pop();
-        jobsCompletedHistory.pop();
+        $('.completed_jobs').text(completedJobs);
+        $('.failed_jobs').text(failedJobsCount);
+        $('.queue_count').text(queuedJobs.length);
+        $('.queued_jobs_count').text(queuedJobsCount);
+        $('.workers_count').text(workersCount);
       }
+    });
+  },
+  getQueueData: function() {
+    $.ajax({
+      url: '/queues-data',
+      success: function(data) {
+        var deserializedData = JSON.parse(data);
+        var queuedJobs = deserializedData.queued_jobs;
+        var total = 0;
 
-      drawChart();
-
-      var workersCount = deserializedData.workers_count;
+        for (var i = 0; i < queuedJobs.length; i++) {
+          $('#queue_name_' + queuedJobs[i][0].split(':').pop()).text(queuedJobs[i][0]);
+          $('#queue_count_' + queuedJobs[i][0].split(':').pop()).text(queuedJobs[i][1]);
+          total = total + queuedJobs[i][1];
+        }
 
-      $('.completed_jobs').text(completedJobs);
-      $('.failed_jobs').text(failedJobsCount);
-      $('.queue_count').text(queuedJobs.length);
-      $('.queued_jobs_count').text(queuedJobsCount);
-      $('.workers_count').text(workersCount);
-    }
-  });
-}
-
-function getQueueData() {
-  $.ajax({
-    url: '/queue-data',
-    success: function(data) {
-      var deserializedData = JSON.parse(data);
-      var queuedJobs = deserializedData.queued_jobs;
-      var total = 0;
-
-      for (var i = 0; i < queuedJobs.length; i++) {
-        $('#queue_name_' + queuedJobs[i][0].split(':').pop()).text(queuedJobs[i][0]);
-        $('#queue_count_' + queuedJobs[i][0].split(':').pop()).text(queuedJobs[i][1]);
-        total = total + queuedJobs[i][1];
+        $('#queue_total').text(total);
       }
+    });
+  },
+  getDetailData: function() {
+    $.ajax({
+      url: '/details-data',
+      success: function(data) {
+        var deserializedData = JSON.parse(data);
+        var completedJobs = deserializedData.completed_jobs;
+        var failedJobs = deserializedData.failed_jobs;
+        var completedTotal = 0;
+        var failedTotal = 0;
 
-      $('#queue_total').text(total);
-    }
-  });
-}
-
-function getDetailData() {
-  $.ajax({
-    url: '/detail-data',
-    success: function(data) {
-      var deserializedData = JSON.parse(data);
-      var completedJobs = deserializedData.completed_jobs;
-      var failedJobs = deserializedData.failed_jobs;
-      var completedTotal = 0;
-      var failedTotal = 0;
+        completedJobs.forEach(function(job) {
+          $('#completed_' + job[0]).text(job[1]);
+          completedTotal = completedTotal + job[1];
+        });
 
-      completedJobs.forEach(function(job) {
-        $('#completed_' + job[0]).text(job[1]);
-        completedTotal = completedTotal + job[1];
-      });
+        failedJobs.forEach(function(job) {
+          $('#failed_' + job[0]).text(job[1]);
+          failedTotal = failedTotal + job[1];
+        });
 
-      failedJobs.forEach(function(job) {
-        $('#failed_' + job[0]).text(job[1]);
-        failedTotal = failedTotal + job[1];
-      });
+        $('#failed_total').text(failedTotal);
+        $('#completed_total').text(completedTotal);
+      }
+    })
+  },
+  drawChart: function() {
+    var processedJobsChart = new CanvasJS.Chart('jobs_processed_container', {
+      title: {
+        text: 'Jobs Processed per second',
+        fontFamily: 'Arial',
+        fontSize: 24,
+      },
+      axisX: {
+        reversed: true,
+        gridColor: 'Silver',
+        tickColor: 'silver',
+        animationEnabled: true,
+        title: 'Time ago (s)',
+        maximum: 60
+      },
+      toolTip: {
+        shared: true
+      },
+      theme: "theme2",
+      axisY: {
+        gridColor: "Silver",
+        tickColor: "silver",
+        title: 'Jobs per second',
+      },
+      data: [{
+        type: "line",
+        showInLegend: true,
+        name: "Jobs completed",
+        color: "blue",
+        markerType: 'circle',
+        lineThickness: 2,
+        dataPoints: [
+          { x: '0', y: (this.jobsCompletedHistory[0] - this.jobsCompletedHistory[1]) / 5 || 0 },
+          { x: '5', y: (this.jobsCompletedHistory[1] - this.jobsCompletedHistory[2]) / 5 || 0 },
+          { x: '10', y: (this.jobsCompletedHistory[2] - this.jobsCompletedHistory[3]) / 5 || 0 },
+          { x: '15', y: (this.jobsCompletedHistory[3] - this.jobsCompletedHistory[4]) / 5 || 0 },
+          { x: '20', y: (this.jobsCompletedHistory[4] - this.jobsCompletedHistory[5]) / 5 || 0 },
+          { x: '25', y: (this.jobsCompletedHistory[5] - this.jobsCompletedHistory[6]) / 5 || 0 },
+          { x: '30', y: (this.jobsCompletedHistory[6] - this.jobsCompletedHistory[7]) / 5 || 0 },
+          { x: '35', y: (this.jobsCompletedHistory[7] - this.jobsCompletedHistory[8]) / 5 || 0 },
+          { x: '40', y: (this.jobsCompletedHistory[8] - this.jobsCompletedHistory[9]) / 5 || 0 },
+          { x: '45', y: (this.jobsCompletedHistory[9] - this.jobsCompletedHistory[10]) / 5 || 0 },
+          { x: '50', y: (this.jobsCompletedHistory[10] - this.jobsCompletedHistory[11]) / 5 || 0 },
+          { x: '55', y: (this.jobsCompletedHistory[11] - this.jobsCompletedHistory[12]) / 5 || 0 },
+          { x: '60', y: (this.jobsCompletedHistory[12] - this.jobsCompletedHistory[13]) / 5 || 0 },
+        ]
+      }]
+    });
 
-      $('#failed_total').text(failedTotal);
-      $('#completed_total').text(completedTotal);
-    }
-  })
-}
+    var queuedJobsChart = new CanvasJS.Chart('queued_jobs_container', {
+      title: {
+        text: 'Queued Jobs',
+        fontFamily: 'Arial',
+        fontSize: 24,
+      },
+      axisX: {
+        reversed: true,
+        gridColor: 'Silver',
+        tickColor: 'silver',
+        animationEnabled: true,
+        title: 'Time ago (s)',
+        // minimum: 0,
+        maximum: 60
+      },
+      toolTip: {
+        shared: true
+      },
+      theme: "theme2",
+      axisY: {
+        gridColor: "Silver",
+        tickColor: "silver",
+        title: 'Jobs'
+      },
+      data: [{
+        type: "line",
+        showInLegend: true,
+        lineThickness: 2,
+        name: "Queued Jobs",
+        markerType: "circle",
+        color: "#F08080",
+        dataPoints: this.setDataPoints(this.queuedJobsCountHistory),
+      }],
+    });
 
-function drawChart() {
-  var processedJobsChart = new CanvasJS.Chart('jobs_processed_container', {
-    title: {
-      text: 'Jobs Processed',
-      fontSize: 24,
-    },
-    axisX: {
-      reversed: true,
-      gridColor: 'Silver',
-      tickColor: 'silver',
-      animationEnabled: true,
-      title: 'Time ago (s)',
-      maximum: 60
-    },
-    toolTip: {
-      shared: true
-    },
-    theme: "theme2",
-    axisY: {
-      gridColor: "Silver",
-      tickColor: "silver",
-      title: 'Jobs'
-    },
-    data: [{
-      type: "line",
-      showInLegend: true,
-      name: "Jobs completed",
-      color: "blue",
-      markerType: 'circle',
-      lineThickness: 2,
-      dataPoints: [
-        { x: '0', y: jobsCompletedHistory[0] },
-        { x: '5', y: jobsCompletedHistory[1] },
-        { x: '10', y: jobsCompletedHistory[2] },
-        { x: '15', y: jobsCompletedHistory[3] },
-        { x: '20', y: jobsCompletedHistory[4] },
-        { x: '25', y: jobsCompletedHistory[5] },
-        { x: '30', y: jobsCompletedHistory[6] },
-        { x: '35', y: jobsCompletedHistory[7] },
-        { x: '40', y: jobsCompletedHistory[8] },
-        { x: '45', y: jobsCompletedHistory[9] },
-        { x: '50', y: jobsCompletedHistory[10] },
-        { x: '55', y: jobsCompletedHistory[11] },
-        { x: '60', y: jobsCompletedHistory[12] },
+    var failedJobsChart = new CanvasJS.Chart('failed_jobs_container', {
+      title: {
+        text: 'Failed Jobs',
+        fontFamily: 'Arial',
+        fontSize: 24,
+      },
+      axisX: {
+        reversed: true,
+        gridColor: 'Silver',
+        tickColor: 'silver',
+        animationEnabled: true,
+        title: 'Time ago (s)',
+        // minimum: 0,
+        maximum: 60
+      },
+      toolTip: {
+        shared: true
+      },
+      theme: "theme2",
+      axisY: {
+        gridColor: "Silver",
+        tickColor: "silver",
+        title: 'Jobs'
+      },
+      data: [{
+          type: "line",
+          showInLegend: true,
+          name: "Failed Jobs",
+          color: "#20B2AA",
+          markerType: 'circle',
+          lineThickness: 2,
+          dataPoints: this.setDataPoints(this.failedJobsCountHistory),
+        },
       ]
-    }]
-  });
+    });
 
-  var queuedJobsChart = new CanvasJS.Chart('queued_jobs_container', {
-    title: {
-      text: 'Queued Jobs',
-      fontSize: 24,
-    },
-    axisX: {
-      reversed: true,
-      gridColor: 'Silver',
-      tickColor: 'silver',
-      animationEnabled: true,
-      title: 'Time ago (s)',
-      // minimum: 0,
-      maximum: 60
-    },
-    toolTip: {
-      shared: true
-    },
-    theme: "theme2",
-    axisY: {
-      gridColor: "Silver",
-      tickColor: "silver",
-      title: 'Jobs'
-    },
-    data: [{
-      type: "line",
-      showInLegend: true,
-      lineThickness: 2,
-      name: "Queued Jobs",
-      markerType: "circle",
-      color: "#F08080",
-      dataPoints: [
-          { x: '0', y: queuedJobsCountHistory[0] },
-          { x: '5', y: queuedJobsCountHistory[1] },
-          { x: '10', y: queuedJobsCountHistory[2] },
-          { x: '15', y: queuedJobsCountHistory[3] },
-          { x: '20', y: queuedJobsCountHistory[4] },
-          { x: '25', y: queuedJobsCountHistory[5] },
-          { x: '30', y: queuedJobsCountHistory[6] },
-          { x: '35', y: queuedJobsCountHistory[7] },
-          { x: '40', y: queuedJobsCountHistory[8] },
-          { x: '45', y: queuedJobsCountHistory[9] },
-          { x: '50', y: queuedJobsCountHistory[10] },
-          { x: '55', y: queuedJobsCountHistory[11] },
-          { x: '60', y: queuedJobsCountHistory[12] },
-        ]
+    var totalMemoryChart = new CanvasJS.Chart('total_memory_container', {
+      title: {
+        text: 'Memory Usage',
+        fontFamily: 'Arial',
+        fontSize: 24,
       },
-    ],
-  });
-
-  var failedJobsChart = new CanvasJS.Chart('failed_jobs_container', {
-    title: {
-      text: 'Failed Jobs',
-      fontSize: 24,
-    },
-    axisX: {
-      reversed: true,
-      gridColor: 'Silver',
-      tickColor: 'silver',
-      animationEnabled: true,
-      title: 'Time ago (s)',
-      // minimum: 0,
-      maximum: 60
-    },
-    toolTip: {
-      shared: true
-    },
-    theme: "theme2",
-    axisY: {
-      gridColor: "Silver",
-      tickColor: "silver",
-      title: 'Jobs'
-    },
-    data: [{
+      axisX: {
+        reversed: true,
+        gridColor: 'Silver',
+        tickColor: 'silver',
+        animationEnabled: true,
+        title: 'Time ago (s)',
+        // minimum: 0,
+        maximum: 60
+      },
+      toolTip: {
+        shared: true
+      },
+      theme: "theme2",
+      axisY: {
+        gridColor: "Silver",
+        tickColor: "silver",
+        title: 'Memory (mb)'
+      },
+      data: [{
         type: "line",
         showInLegend: true,
-        name: "Failed Jobs",
+        name: "Memory usage",
         color: "#20B2AA",
         markerType: 'circle',
         lineThickness: 2,
-        dataPoints: [
-          { x: '0', y: failedJobsCountHistory[0] },
-          { x: '5', y: failedJobsCountHistory[1] },
-          { x: '10', y: failedJobsCountHistory[2] },
-          { x: '15', y: failedJobsCountHistory[3] },
-          { x: '20', y: failedJobsCountHistory[4] },
-          { x: '25', y: failedJobsCountHistory[5] },
-          { x: '30', y: failedJobsCountHistory[6] },
-          { x: '35', y: failedJobsCountHistory[7] },
-          { x: '40', y: failedJobsCountHistory[8] },
-          { x: '45', y: failedJobsCountHistory[9] },
-          { x: '50', y: failedJobsCountHistory[10] },
-          { x: '55', y: failedJobsCountHistory[11] },
-          { x: '60', y: failedJobsCountHistory[12] },
-        ]
-      },
-    ]
-  });
+        dataPoints: this.setDataPoints(this.totalMemoryHistory),
+      }],
+    });
+
+    queuedJobsChart.render();
+    failedJobsChart.render();
+    processedJobsChart.render();
+    totalMemoryChart.render();
+  },
+  setDataPoints: function(array) {
+    data = [
+      { x: '0', y: array[0] },
+      { x: '5', y: array[1] },
+      { x: '10', y: array[2] },
+      { x: '15', y: array[3] },
+      { x: '20', y: array[4] },
+      { x: '25', y: array[5] },
+      { x: '30', y: array[6] },
+      { x: '35', y: array[7] },
+      { x: '40', y: array[8] },
+      { x: '45', y: array[9] },
+      { x: '50', y: array[10] },
+      { x: '55', y: array[11] },
+      { x: '60', y: array[12] },
+    ];
+
+    return data;
+  },
+  setActiveTab: function() {
+    this.tab = $(location).attr('href').split('/').pop();
+    var $active = $('a[href=' + this.tab + ']');
+
+    $active.css('background', '#a2a2a2');
+    $active.css('color', '#fff');
+  },
+  pollData: function(tab) {
+    if (tab === 'overview') {
+      this.getOverviewData();
 
-  queuedJobsChart.render();
-  failedJobsChart.render();
-  processedJobsChart.render();
+      setInterval(function() {
+        this.getOverviewData();
+      }.bind(this), 5000);
+    }
+
+    if (tab === 'queues') {
+      setInterval(function() {
+        this.getQueueData();
+      }.bind(this), 5000);
+    }
+
+    if (tab === 'details') {
+      setInterval(function() {
+        this.getDetailData();
+      }.bind(this), 5000);
+    }
+  },
+  bindEvents: function() {
+    $('#memory_usage').on('click', function(e) {
+      $('.nested th').toggle();
+    });
+  },
+  init: function() {
+    this.setActiveTab();
+    this.bindEvents();
+    this.pollData(this.tab);
+  }
 }
+
+$(document).ready(App.init.bind(App));