exel 1.2.1 → 1.3.0

data/lib/exel/logging_helper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module EXEL
+  # Logging related helper methods for processors
+  module LoggingHelper
+    # @return [Logger] Returns the EXEL logger
+    def logger
+      EXEL.logger
+    end
+
+    # Logs a message with DEBUG severity
+    def log_debug(message)
+      logger.debug(message)
+    end
+
+    # Logs a message with INFO severity
+    def log_info(message)
+      logger.info(message)
+    end
+
+    # Logs a message with WARN severity
+    def log_warn(message)
+      logger.warn(message)
+    end
+
+    # Logs a message with ERROR severity
+    def log_error(message)
+      logger.error(message)
+    end
+
+    # Logs a message with FATAL severity
+    def log_fatal(message)
+      logger.fatal(message)
+    end
+  end
+end

data/lib/exel/middleware/chain.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module EXEL
+  # Middleware is code configured to run around each processor execution. Custom middleware can be added as follows:
+  #
+  #   EXEL.configure do |config|
+  #     config.middleware.add(MyMiddleware)
+  #     config.middleware.add(AnotherMiddleware, 'constructor arg')
+  #   end
+  #
+  # Middleware can be any class that implements a +call+ method that includes a call to +yield+:
+  #
+  #   class MyMiddleware
+  #     def call(processor, context, args)
+  #       puts 'before process'
+  #       yield
+  #       puts 'after process'
+  #     end
+  #   end
+  #
+  # The +call+ method will be passed the class of the processor that will be executed, the current context, and any args
+  # that were passed to the processor in the job definition.
+  module Middleware
+    # Chain of middleware to be invoked in sequence around each processor execution.
+    class Chain
+      attr_reader :entries
+
+      Entry = Struct.new(:klass, :args)
+
+      def initialize
+        @entries = []
+      end
+
+      # Adds a middleware class to the chain. If it is already in the chain it will be removed and added to the end.
+      # Any additional arguments will be passed to +new+ when the middleware is created.
+      def add(klass, *args)
+        remove(klass)
+        @entries << Entry.new(klass, args)
+      end
+
+      # Removes a middleware class from the chain.
+      def remove(klass)
+        @entries.delete_if { |entry| entry.klass == klass }
+      end
+
+      # Returns true if the given class is in the chain.
+      def include?(klass)
+        @entries.any? { |entry| entry.klass == klass }
+      end
+
+      # Calls each middleware in the chain.
+      def invoke(*args)
+        chain = @entries.map { |entry| entry.klass.new(*entry.args) }
+
+        traverse_chain = lambda do
+          if chain.empty?
+            yield
+          else
+            chain.shift.call(*args, &traverse_chain)
+          end
+        end
+
+        traverse_chain.call
+      end
+    end
+  end
+end

data/lib/exel/middleware/logging.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module EXEL
+  module Middleware
+    # Middleware to add a prefix to all messages logged during processor execution. The prefix is specified by the
+    # +:log_prefix+ key in the context. Also logs start, finish, and failure of the processor execution.
+    class Logging
+      def call(processor_class, context, _args, &block)
+        EXEL::Logging.with_prefix("#{context[:log_prefix]}[#{processor_class}] ") { log_process(&block) }
+      end
+
+      private
+
+      def log_process
+        start_time = Time.now
+        EXEL.logger.info 'Starting'
+
+        yield
+
+        EXEL.logger.info "Finished in #{duration(start_time)} seconds"
+      rescue Exception # rubocop:disable Lint/RescueException
+        EXEL.logger.info "Failed in #{duration(start_time)} seconds"
+        raise
+      end
+
+      def duration(start_time)
+        (Time.now - start_time).round(3)
+      end
+    end
+  end
+end

data/lib/exel/null_instruction.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module EXEL
   # An {Instruction} that does nothing when executed
   class NullInstruction

data/lib/exel/processor_helper.rb

@@ -1,6 +1,13 @@
+# frozen_string_literal: true
 module EXEL
   # Helper methods useful to processors
+  # @deprecated Most functionality replaced by {EXEL::Middleware::Logging} middleware.
   module ProcessorHelper
+    def self.included(other)
+      warn "DEPRECATION WARNING: [#{other}] EXEL::ProcessorHelper will be removed. For process logging, please use "\
+           'EXEL::Middleware::Logging instead'
+    end
+
     def tag(*tags)
       tags.map { |t| "[#{t}]" }.join('')
     end

data/lib/exel/processors/async_processor.rb

@@ -1,24 +1,18 @@
-require_relative '../processor_helper'
+# frozen_string_literal: true
 
 module EXEL
   module Processors
     # Implements the +async+ instruction by using the configured async provider to run a block asynchronously.
     class AsyncProcessor
-      include EXEL::ProcessorHelper
       attr_reader :provider
 
       def initialize(context)
         @context = context
         @provider = EXEL.async_provider.new(context)
-
-        log_prefix_with '[AsyncProcessor]'
       end
 
       def process(block)
-        log_process do
-          @provider.do_async(block)
-          log_info 'call to async completed'
-        end
+        @provider.do_async(block)
       end
     end
   end

data/lib/exel/processors/run_processor.rb

@@ -1,11 +1,8 @@
-require_relative '../processor_helper'
-
+# frozen_string_literal: true
 module EXEL
   module Processors
     # Implements the +run+ instruction.
     class RunProcessor
-      include EXEL::ProcessorHelper
-
       # Requires +context[:job]+ to contain the name of the job to be run.
       def initialize(context)
         @context = context
@@ -13,9 +10,7 @@ module EXEL
 
       # Runs the specified job with the current context
       def process(_block = nil)
-        log_process "running job #{@context[:job]}" do
-          EXEL::Job.run(@context[:job], @context)
-        end
+        EXEL::Job.run(@context[:job], @context)
       end
     end
   end

data/lib/exel/processors/split_processor.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require 'csv'
 require 'tempfile'
-require_relative '../processor_helper'
+require_relative '../logging_helper'
 
 module EXEL
   module Processors
@@ -12,7 +13,7 @@ module EXEL
     #   be deleted when splitting is complete
     # * +:chunk_size+ Set to specify the number of lines that each chunk should contain
     class SplitProcessor
-      include EXEL::ProcessorHelper
+      include EXEL::LoggingHelper
 
       attr_accessor :file_name, :block
 
@@ -26,15 +27,11 @@ module EXEL
         @context = context
         @file = context[:resource]
         @context[:delete_resource] = true if @context[:delete_resource].nil?
-
-        log_prefix_with '[SplitProcessor]'
       end
 
       def process(callback)
-        log_process do
-          process_file(callback)
-          finish(callback)
-        end
+        process_file(callback)
+        finish(callback)
       end
 
       def process_line(line, callback)

data/lib/exel/providers/local_file_provider.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module EXEL
   module Providers
     # The default remote provider. Doesn't actually upload and download files to and from remote storage, but rather

data/lib/exel/providers/threaded_async_provider.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module EXEL
   module Providers
     # The default remote provider. Provides async execution by running the given EXEL block in a new Thread

data/lib/exel/sequence_node.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative './ast_node'
 
 module EXEL

data/lib/exel/value.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module EXEL
   # Contains methods to handle remote and local values. Used for {Context} serialization
   module Value

data/lib/exel/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module EXEL
-  VERSION = '1.2.1'.freeze
+  VERSION = '1.3.0'
 end

data/spec/exel/ast_node_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module EXEL
   describe ASTNode do
     let(:context) { instance_double(EXEL::Context) }
@@ -9,13 +10,33 @@ module EXEL
     TestNode = Class.new(ASTNode)
 
     describe '#start' do
-      context 'when an JobTermination error bubbles up' do
-        it 'ensures the process fails silently' do
-          node = TestNode.new(instruction)
+      context 'when a JobTermination error bubbles up' do
+        let(:node) { TestNode.new(instruction) }
+
+        before do
           allow(node).to receive(:run).and_raise(EXEL::Error::JobTermination, 'Error')
+        end
+
+        it 'ensures the process fails silently' do
           expect(EXEL.logger).to receive(:error).with('JobTerminationError: Error')
           expect { node.start(context) }.not_to raise_error
         end
+
+        it 'logs the error by default' do
+          expect(EXEL.logger).to receive(:error).with('JobTerminationError: Error')
+          node.start(context)
+        end
+
+        context 'given a log instruction' do
+          before do
+            allow(node).to receive(:run).and_raise(EXEL::Error::JobTermination.new('Error', :warn))
+          end
+
+          it 'logs the error with the given cmd' do
+            expect(EXEL.logger).to receive(:warn).with('JobTerminationError: Error')
+            node.start(context)
+          end
+        end
       end
     end
 

data/spec/exel/context_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module EXEL
   describe Context do
     subject(:context) { EXEL::Context.new(key1: '1', key2: 2) }

data/spec/exel/deferred_context_value_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module EXEL
   describe DeferredContextValue do
     subject(:deferred_value) { DeferredContextValue.new }

data/spec/exel/events_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module EXEL
   describe Events do
     class EventTest

data/spec/exel/instruction_node_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module EXEL
   describe InstructionNode do
     let(:context) { {} }

data/spec/exel/instruction_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module EXEL
   describe Instruction do
     subject(:instruction) { EXEL::Instruction.new(processor_class, args) }
@@ -14,6 +15,11 @@ module EXEL
         instruction.execute(context)
       end
 
+      it 'invokes the middleware chain' do
+        expect(EXEL.middleware).to receive(:invoke).with(processor_class, context, args)
+        instruction.execute(context)
+      end
+
       it 'does not pass a copy of the context' do
         allow(processor_class).to receive(:new) do |context_arg|
           expect(context_arg).to be(context)

data/spec/exel/job_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module EXEL
   describe Job do
     describe '.define' do

data/spec/exel/listen_instruction_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module EXEL
   describe ListenInstruction do
     subject(:instruction) { EXEL::ListenInstruction.new(:event, listener) }

data/spec/exel/logging/logger_wrapper_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+module EXEL
+  module Logging
+    describe LoggerWrapper do
+      subject(:wrapper) { LoggerWrapper.new(logger) }
+      let(:logger) { instance_double(Logger) }
+
+      it { is_expected.to be_a(SimpleDelegator) }
+
+      LOG_LEVELS = %i(debug info warn error fatal unknown).freeze
+
+      context 'without a Logging prefix' do
+        LOG_LEVELS.each do |level|
+          describe "##{level}" do
+            context 'when passed a message string' do
+              it 'passes the message to its wrapped logger' do
+                expect(logger).to receive(level).with('message')
+                wrapper.send(level, 'message')
+              end
+            end
+
+            context 'when passed a message block' do
+              it 'passes the block to its wrapped logger' do
+                block = proc {}
+                expect(logger).to receive(level).with(nil, &block)
+
+                wrapper.send(level, &block)
+              end
+
+              context 'and a progname' do
+                it 'passes the block and progname to its wrapped logger' do
+                  block = proc {}
+                  expect(logger).to receive(level).with('test', &block)
+
+                  wrapper.send(level, 'test', &block)
+                end
+              end
+            end
+          end
+        end
+
+        describe '#add' do
+          it 'passes the message to its wrapped logger' do
+            expect(logger).to receive(:add).with(Logger::FATAL, 'message', 'progname')
+            wrapper.add(Logger::FATAL, 'message', 'progname')
+          end
+        end
+      end
+
+      context 'with a Logging prefix' do
+        before { allow(Logging).to receive(:prefix).and_return('prefix: ') }
+
+        LOG_LEVELS.each do |level|
+          describe "##{level}" do
+            context 'when passed a message string' do
+              it 'passes the prefixed message to its wrapped logger' do
+                expect(logger).to receive(level).with('prefix: message')
+                wrapper.send(level, 'message')
+              end
+            end
+
+            context 'when passed a message block' do
+              it 'passes the prefixed block to its wrapped logger' do
+                expect(logger).to receive(level) do |progname, &block|
+                  expect(progname).to be_nil
+                  expect(block.call).to eq('prefix: message')
+                end
+
+                wrapper.send(level) { 'message' }
+              end
+
+              context 'and a progname' do
+                it 'passes the prefixed block and progname to its wrapped logger' do
+                  expect(logger).to receive(level) do |progname, &block|
+                    expect(progname).to eq('test')
+                    expect(block.call).to eq('prefix: message')
+                  end
+
+                  wrapper.send(level, 'test') { 'message' }
+                end
+              end
+            end
+          end
+        end
+
+        describe '#add' do
+          it 'passes the prefixed message to its wrapped logger' do
+            expect(logger).to receive(:add).with(Logger::FATAL, 'prefix: message', 'progname')
+            wrapper.add(Logger::FATAL, 'message', 'progname')
+          end
+        end
+      end
+    end
+  end
+end