funktor 0.4.6 → 0.6.1

data/lib/funktor/job_activator.rb

@@ -0,0 +1,124 @@
+require 'aws-sdk-dynamodb'
+require 'aws-sdk-sqs'
+
+module Funktor
+  class JobActivator
+
+    def initialize
+      @tracker = Funktor::ActivityTracker.new
+    end
+
+    def dynamodb_client
+      @dynamodb_client ||= ::Aws::DynamoDB::Client.new
+    end
+
+    def sqs_client
+      @sqs_client ||= ::Aws::SQS::Client.new
+    end
+
+    def delayed_job_table
+      ENV['FUNKTOR_JOBS_TABLE']
+    end
+
+    def jobs_to_activate
+      # TODO : The lookahead time here should be configurable
+      # If this doesn't match the setting in the IncomingJobHandler some jobs
+      # might be activated and then immediately re-scheduled instead of being
+      # queued, which leads to kind of confusing stats for the "incoming" stat.
+      # (Come to think of it, the incoming stat is kind of confusting anyway since
+      # it reflects retries and scheduled jobs activations...)
+      target_time = (Time.now + 60).utc
+      query_params = {
+        expression_attribute_values: {
+          ":queueable" => "true",
+          ":targetTime" => target_time.iso8601
+        },
+        key_condition_expression: "queueable = :queueable AND performAt < :targetTime",
+        projection_expression: "jobId, jobShard, category",
+        table_name: delayed_job_table,
+        index_name: "performAtIndex"
+      }
+      resp = dynamodb_client.query(query_params)
+      return resp.items
+    end
+
+    def queue_for_job(job)
+      queue_name = job.queue || 'default'
+      queue_constant = "FUNKTOR_#{queue_name.underscore.upcase}_QUEUE"
+      Funktor.logger.debug "queue_constant = #{queue_constant}"
+      Funktor.logger.debug "ENV value = #{ENV[queue_constant]}"
+      ENV[queue_constant] || ENV['FUNKTOR_DEFAULT_QUEUE']
+    end
+
+    def handle_item(item)
+      job_shard = item["jobShard"]
+      job_id = item["jobId"]
+      current_category = item["category"]
+      Funktor.logger.debug "jobShard = #{item['jobShard']}"
+      Funktor.logger.debug "jobId = #{item['jobId']}"
+      Funktor.logger.debug "current_category = #{current_category}"
+      activate_job(job_shard, job_id, current_category)
+    end
+
+    def activate_job(job_shard, job_id, current_category, queue_immediately = false)
+      # First we conditionally update the item in  Dynamo to be sure that another scheduler hasn't gotten
+      # to it, and if that works then send to SQS. This is basically how Sidekiq scheduler works.
+      response = dynamodb_client.update_item({
+        key: {
+          "jobShard" => job_shard,
+          "jobId" => job_id
+        },
+        update_expression: "SET category = :category, queueable = :queueable",
+        condition_expression: "category = :current_category",
+        expression_attribute_values: {
+          ":current_category" => current_category,
+          ":queueable" => "false",
+          ":category" => "queued"
+        },
+        table_name: delayed_job_table,
+        return_values: "ALL_OLD"
+      })
+      if response.attributes # this means the record was still there in the state we expected
+        Funktor.logger.debug "response.attributes ====== "
+        Funktor.logger.debug response.attributes
+        job = Funktor::Job.new(response.attributes["payload"])
+        Funktor.logger.debug "we created a job from payload"
+        Funktor.logger.debug response.attributes["payload"]
+        Funktor.logger.debug "queueing to #{job.retry_queue_url}"
+        if queue_immediately
+          job.delay = 0
+        end
+        sqs_client.send_message({
+          queue_url: job.retry_queue_url,
+          message_body: job.to_json
+          #delay_seconds: job.delay
+        })
+        if job.is_retry?
+          # We don't track here because we send stuff back to the incoming job queue and we track the
+          # :retryActivated even there.
+          # TODO - Once we're sure this is all working right we can delete the commented out line.
+          #@tracker.track(:retryActivated, job)
+        else
+          @tracker.track(:scheduledJobActivated, job)
+        end
+      end
+    rescue ::Aws::DynamoDB::Errors::ConditionalCheckFailedException => e
+      # This means that a different instance of the JobActivator (or someone doing stuff in the web UI)
+      # got to the job first.
+      Funktor.logger.debug "#{e.to_s} : #{e.message}"
+      Funktor.logger.debug e.backtrace.join("\n")
+    end
+
+    def call(event:, context:)
+      handled_item_count = 0
+      jobs_to_activate.each do |item|
+        if context.get_remaining_time_in_millis < 5_000 # This lets us exit gracefully and resume on the next round instead of getting forcibly killed.
+          puts "Bailing out due to milliseconds remaining #{context.get_remaining_time_in_millis}"
+          break
+        end
+        handle_item(item)
+        handled_item_count += 1
+      end
+    end
+  end
+end

data/lib/funktor/job_pusher.rb

@@ -4,8 +4,6 @@ module Funktor
   class JobPusher
 
     def push(payload)
-      puts "payload ============"
-      pp payload
       job_id = SecureRandom.uuid
       payload[:job_id] = job_id
 

data/lib/funktor/middleware/metrics.rb

@@ -10,7 +10,12 @@ module Funktor
       end
 
       def put_metric_to_stdout(time_diff, job)
-        puts Funktor.dump_json(metric_hash(time_diff, job))
+        # NOTE : We use raw_logger here instead of Funktor.loggert o avoid getting extra
+        # timestamps or log level information in the log line. We need this specific format to
+        # be the only thing in the line so that CloudWatch can parse the logs and use the data.
+        # 'unknown' is a log level that will always be logged, no matter what is set in the
+        # runtime environment as far as log level.
+        Funktor.raw_logger.unknown Funktor.dump_json(metric_hash(time_diff, job))
       end
 
       def metric_hash(time_diff_in_seconds, job)
@@ -43,8 +48,8 @@ module Funktor
   end
 end
 
-Funktor.configure_active_job_handler do |config|
-  config.active_job_handler_middleware do |chain|
+Funktor.configure_work_queue_handler do |config|
+  config.work_queue_handler_middleware do |chain|
     chain.add Funktor::Middleware::Metrics
   end
 end

data/lib/funktor/shard_utils.rb

@@ -0,0 +1,6 @@
+module ShardUtils
+  def calculate_shard(job_id)
+    # TODO - Should the number of shards be configurable?
+    job_id.sum % 64
+  end
+end

data/lib/funktor/testing.rb

@@ -1,7 +1,9 @@
 require 'funktor/worker'
+require 'funktor/job_pusher'
 require 'funktor/fake_job_queue'
 
 module Funktor
+
   module Worker
     def self.clear_all
       Funktor::FakeJobQueue.clear_all
@@ -25,47 +27,68 @@ module Funktor
       end
     end
   end
+
   class Testing
+    class << self
+      attr_accessor :mode
 
-    def self.inline!(&block)
-      Funktor.configure_job_pusher do |config|
-        config.job_pusher_middleware do |chain|
-          chain.add Funktor::InlineJobPusherMiddleware
-        end
+      def inline?
+        mode == :inline
       end
-      yield
-      Funktor.configure_job_pusher do |config|
-        config.job_pusher_middleware do |chain|
-          chain.remove Funktor::InlineJobPusherMiddleware
-        end
+
+      def fake?
+        mode == :fake
       end
-    end
-    def self.fake!(&block)
-      Funktor.configure_job_pusher do |config|
-        config.job_pusher_middleware do |chain|
-          chain.add Funktor::FakeJobPusherMiddleware
+
+      def inline!(&block)
+        unless block_given?
+          raise "Funktor inline testing mode can only be called in block form."
         end
+        set_mode(:inline, &block)
+      end
+
+      def fake!(&block)
+        set_mode(:fake, &block)
       end
-      yield
-      Funktor.configure_job_pusher do |config|
-        config.job_pusher_middleware do |chain|
-          chain.remove Funktor::FakeJobPusherMiddleware
+
+      def disable!
+        set_mode(:disabled)
+      end
+
+      def set_mode(new_mode, &block)
+        if block_given?
+          original_mode = mode
+          self.mode = new_mode
+          begin
+            yield
+          ensure
+            self.mode = original_mode
+          end
+        else
+          self.mode = new_mode
         end
       end
     end
   end
 
-  class InlineJobPusherMiddleware
-    def call(payload)
-      payload = payload.with_indifferent_access
-      worker = Object.const_get payload["worker"]
-      worker.new.perform(*payload["worker_params"])
+  module TestingPusher
+    def push(payload)
+      if Funktor::Testing.inline?
+        Funktor.job_pusher_middleware.invoke(payload) do
+          payload = payload.with_indifferent_access
+          worker = Object.const_get payload["worker"]
+          worker.new.perform(*payload["worker_params"])
+        end
+      elsif Funktor::Testing.fake?
+        Funktor.job_pusher_middleware.invoke(payload) do
+          Funktor::FakeJobQueue.push(payload)
+        end
+      else
+        super
+      end
     end
   end
 
-  class FakeJobPusherMiddleware
-    def call(payload)
-      Funktor::FakeJobQueue.push(payload)
-    end
-  end
+  Funktor::JobPusher.prepend TestingPusher
+
 end

data/lib/funktor/version.rb

@@ -1,3 +1,3 @@
 module Funktor
-  VERSION = "0.4.6"
+  VERSION = "0.6.1"
 end

data/lib/funktor/web/application.rb

@@ -0,0 +1,139 @@
+require 'sinatra/base'
+require 'aws-sdk-dynamodb'
+require_relative '../../funktor'
+require_relative '../../funktor/shard_utils'
+require_relative '../../funktor/activity_tracker'
+
+module Funktor
+  module Web
+    class Application < Sinatra::Base
+      include ShardUtils
+
+      get '/' do
+        erb :index, layout: :layout, locals: {
+          activity_data: get_activity_data
+        }
+      end
+
+      get '/scheduled' do
+        erb :scheduled, layout: :layout, locals: {
+          activity_data: get_activity_data,
+          jobs: get_jobs('scheduled')
+        }
+      end
+
+      get '/retries' do
+        erb :retries, layout: :layout, locals: {
+          activity_data: get_activity_data,
+          jobs: get_jobs('retry')
+        }
+      end
+
+      get '/queued' do
+        erb :queued, layout: :layout, locals: {
+          activity_data: get_activity_data,
+          jobs: get_jobs('queued')
+        }
+      end
+
+      get '/processing' do
+        erb :processing, layout: :layout, locals: {
+          activity_data: get_activity_data,
+          jobs: get_jobs('processing')
+        }
+      end
+
+      post '/update_jobs' do
+        job_ids = params[:job_id]
+        if job_ids.is_a?(String)
+          job_ids = [job_ids]
+        end
+        job_ids ||= []
+        puts "params[:submit] = #{params[:submit]}"
+        puts "job_ids = #{job_ids}"
+        puts "params[:source] = #{params[:source]}"
+        if params[:submit] == "Delete Selected Jobs"
+          delete_jobs(job_ids, params[:source])
+        elsif params[:submit] == "Queue Selected Jobs"
+          queue_jobs(job_ids, params[:source])
+        end
+        redirect request.referrer
+      end
+
+      def get_jobs(category)
+        "Jobs of type #{category}"
+        query_params = {
+          expression_attribute_values: {
+            ":category" => category
+          },
+          key_condition_expression: "category = :category",
+          projection_expression: "payload, performAt, jobId, jobShard",
+          table_name: ENV['FUNKTOR_JOBS_TABLE'],
+          index_name: "categoryIndex"
+        }
+        resp = dynamodb_client.query(query_params)
+        @items = resp.items
+        @jobs = @items.map{ |item| Funktor::Job.new(item["payload"]) }
+        return @jobs
+      end
+
+      def get_activity_data
+        query_params = {
+          expression_attribute_values: {
+            ":category" => "stat"
+          },
+          key_condition_expression: "category = :category",
+          projection_expression: "statName, stat_value",
+          table_name: ENV['FUNKTOR_ACTIVITY_TABLE']
+        }
+        resp = dynamodb_client.query(query_params)
+        @activity_stats = {}
+        resp.items.each do |item|
+          @activity_stats[item["statName"]] = item["stat_value"].to_i
+        end
+        return @activity_stats
+      end
+
+      def queue_jobs(job_ids, source)
+        job_activator = Funktor::JobActivator.new
+        job_ids.each do |job_id|
+          job_shard = calculate_shard(job_id)
+          job_activator.activate_job(job_shard, job_id, source, true)
+        end
+      end
+
+      def delete_jobs(job_ids, source)
+        @tracker = Funktor::ActivityTracker.new
+        job_ids.each do |job_id|
+          delete_single_job(job_id, source)
+        end
+      end
+
+      def delete_single_job(job_id, source)
+        response = dynamodb_client.delete_item({
+          key: {
+            "jobShard" => calculate_shard(job_id),
+            "jobId" => job_id
+          },
+          table_name: ENV['FUNKTOR_JOBS_TABLE'],
+          return_values: "ALL_OLD"
+        })
+        if response.attributes # this means the record was still there
+          if source == "scheduled"
+            @tracker.track(:scheduledJobDeleted, nil)
+          elsif source == "retry"
+            @tracker.track(:retryDeleted, nil)
+          end
+        end
+      end
+
+      def dynamodb_client
+        @dynamodb_client ||= ::Aws::DynamoDB::Client.new
+      end
+
+      # start the server if ruby file executed directly
+      run! if app_file == $0
+    end
+  end
+end
+

data/lib/funktor/web/views/index.erb

@@ -0,0 +1,3 @@
+<p>Hellerrrrrrrrr!</p>
+<p>Activity data = <%= activity_data %></p>
+

data/lib/funktor/web/views/layout.erb

@@ -0,0 +1,58 @@
+<html>
+  <head>
+    <link rel="stylesheet" href="https://unpkg.com/@picocss/pico@latest/css/pico.min.css">
+    <style type="text/css" media="screen">
+      /* Green Light scheme (Default) */
+      /* Can be forced with data-theme="light" */
+      [data-theme="light"],
+      :root:not([data-theme="dark"]) {
+        --primary: #43a047;
+        --primary-hover: #388e3c;
+        --primary-focus: rgba(67, 160, 71, 0.125);
+        --primary-inverse: #FFF;
+      }
+
+      /* Green Dark scheme (Auto) */
+      /* Automatically enabled if user has Dark mode enabled */
+      @media only screen and (prefers-color-scheme: dark) {
+        :root:not([data-theme="light"]) {
+          --primary: #43a047;
+          --primary-hover: #4caf50;
+          --primary-focus: rgba(67, 160, 71, 0.25);
+          --primary-inverse: #FFF;
+        }
+      }
+
+      /* Green Dark scheme (Forced) */
+      /* Enabled if forced with data-theme="dark" */
+      [data-theme="dark"] {
+        --primary: #43a047;
+        --primary-hover: #4caf50;
+        --primary-focus: rgba(67, 160, 71, 0.25);
+        --primary-inverse: #FFF;
+      }
+
+      /* Green (Common styles) */
+      :root {
+        --form-element-active-border-color: var(--primary);
+        --form-element-focus-color: var(--primary-focus);
+        --switch-color: var(--primary-inverse);
+        --switch-checked-background-color: var(--primary);
+      }
+
+      /* custom stuff for the funktor dashboard */
+      table.header h5{
+        margin-bottom: 0;
+      }
+      body > main{
+        padding: 0;
+      }
+    </style>
+  </head>
+  <body>
+    <%= erb :stats %>
+    <main class="container-fluid">
+      <%= yield %>
+    </main>
+  </body>
+</html>