shoryuken-template 0.3.0

data/lib/shoryuken/template/workers/base_worker.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'shoryuken'
+
+module Shoryuken
+  module Template
+    module Workers
+      # Worker base com funcionalidades comuns
+      module BaseWorker
+        def self.included(base)
+          base.include Shoryuken::Worker
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          # Define configurações do worker
+          def worker_options(queue:, auto_delete: true, body_parser: :json, **options)
+            shoryuken_options(
+              queue: queue,
+              auto_delete: auto_delete,
+              body_parser: body_parser,
+              **options
+            )
+        end
+      end
+
+      # Nome do worker para logs e métricas
+        def worker_name
+          self.class.name
+        end
+
+        protected
+
+        # Extrai informações da mensagem SQS
+        def message_attributes(sqs_msg)
+          return {} unless sqs_msg.respond_to?(:message_attributes)
+
+          sqs_msg.message_attributes.transform_values do |attr|
+            attr.respond_to?(:string_value) ? attr.string_value : attr
+          end
+        end
+
+        # Deleta mensagem manualmente
+        def delete_message(sqs_msg)
+          sqs_msg.delete if sqs_msg.respond_to?(:delete)
+        end
+
+        # Muda visibilidade da mensagem
+        def change_message_visibility(sqs_msg, timeout)
+          sqs_msg.change_visibility(visibility_timeout: timeout) if sqs_msg.respond_to?(:change_visibility)
+        end
+
+        # Log estruturado com contexto do worker
+        def log_info(message, **context)
+          Shoryuken::Template.logger.info(message, worker: worker_name, **context)
+        end
+
+        def log_error(message, **context)
+          Shoryuken::Template.logger.error(message, worker: worker_name, **context)
+        end
+
+        def log_warn(message, **context)
+          Shoryuken::Template.logger.warn(message, worker: worker_name, **context)
+        end
+
+        def log_debug(message, **context)
+          Shoryuken::Template.logger.debug(message, worker: worker_name, **context)
+        end
+      end
+    end
+  end
+end

data/lib/shoryuken/template/workers/fifo_worker.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Shoryuken
+  module Template
+    module Workers
+      # Worker FIFO - processa mensagens sequencialmente de filas FIFO
+      # Garante processamento ordenado e sem concorrência
+      # 
+      # Exemplo de uso:
+      #   class MyFifoWorker
+      #     include Shoryuken::Template::Workers::FifoWorker
+      #     
+      #     worker_options queue: 'my-queue.fifo'
+      #     
+      #     def process_message(body, message_group_id)
+      #       # Processamento sequencial garantido por message_group_id
+      #       puts "Processando sequencialmente: #{body}"
+      #     end
+      #   end
+      module FifoWorker
+        def self.included(base)
+          base.include BaseWorker
+          base.class_eval do
+            # FIFO queues devem processar uma mensagem por vez
+            shoryuken_options auto_delete: true
+          end
+        end
+
+        # Método perform do Shoryuken
+        def perform(sqs_msg, body)
+          message_group_id = extract_message_group_id(sqs_msg)
+          deduplication_id = extract_deduplication_id(sqs_msg)
+
+          log_info(
+            "Iniciando processamento FIFO",
+            message_id: sqs_msg.message_id,
+            message_group_id: message_group_id,
+            deduplication_id: deduplication_id,
+            queue: sqs_msg.queue_url
+          )
+
+          # Valida se é realmente uma fila FIFO
+          validate_fifo_queue(sqs_msg)
+
+          ErrorHandler.handle_error(worker_name, sqs_msg) do
+            process_message(body, message_group_id)
+          end
+        end
+
+        private
+
+        # Extrai o Message Group ID da mensagem
+        def extract_message_group_id(sqs_msg)
+          if sqs_msg.respond_to?(:attributes)
+            sqs_msg.attributes['MessageGroupId']
+          end
+        end
+
+        # Extrai o Deduplication ID da mensagem
+        def extract_deduplication_id(sqs_msg)
+          if sqs_msg.respond_to?(:attributes)
+            sqs_msg.attributes['MessageDeduplicationId']
+          end
+        end
+
+        # Valida se a fila é FIFO
+        def validate_fifo_queue(sqs_msg)
+          queue_url = sqs_msg.queue_url
+          unless queue_url.end_with?('.fifo')
+            log_warn(
+              "Worker FIFO sendo usado em fila não-FIFO",
+              queue_url: queue_url
+            )
+          end
+        end
+
+        # Método que deve ser implementado pela classe filha
+        def process_message(body, message_group_id)
+          raise NotImplementedError, "Você deve implementar o método #process_message(body, message_group_id)"
+        end
+      end
+    end
+  end
+end

data/lib/shoryuken/template/workers/parallel_worker.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module Shoryuken
+  module Template
+    module Workers
+      # Worker paralelo - processa mensagens em batch usando threads
+      # 
+      # Exemplo de uso:
+      #   class MyParallelWorker
+      #     include Shoryuken::Template::Workers::ParallelWorker
+      #     
+      #     worker_options queue: 'my-queue', batch: true
+      #     
+      #     def process_message(body)
+      #       # Cada mensagem será processada em uma thread separada
+      #       puts "Processando em thread: #{body}"
+      #     end
+      #   end
+      module ParallelWorker
+        def self.included(base)
+          base.include BaseWorker
+        end
+
+        # Método perform do Shoryuken para batch
+        def perform(sqs_msg, body)
+          # Para batch, sqs_msg e body são arrays
+          messages = sqs_msg.is_a?(Array) ? sqs_msg : [sqs_msg]
+          bodies = body.is_a?(Array) ? body : [body]
+
+          log_info(
+            "Iniciando processamento paralelo de batch",
+            batch_size: messages.size,
+            queue: messages.first&.queue_url
+          )
+
+          start_time = Time.now
+          process_batch_parallel(messages, bodies)
+          duration = Time.now - start_time
+
+          log_info(
+            "Batch processado com sucesso",
+            batch_size: messages.size,
+            duration: duration.round(3)
+          )
+        end
+
+        private
+
+        def process_batch_parallel(messages, bodies)
+          thread_pool = Shoryuken::Template.configuration.thread_pool_for(worker_name)
+          timeout = Shoryuken::Template.configuration.thread_timeout_for(worker_name)
+          
+          # Cria promises para cada mensagem
+          promises = messages.each_with_index.map do |sqs_msg, index|
+            Concurrent::Promise.execute(executor: thread_pool) do
+              process_single_message_with_timeout(sqs_msg, bodies[index], timeout)
+            end
+          end
+
+          # Aguarda todas as promises completarem
+          results = promises.map do |promise|
+            begin
+              promise.value
+            rescue => e
+              log_error(
+                "Erro em thread de processamento",
+                error: e.message,
+                error_class: e.class.name
+              )
+              { success: false, error: e }
+            end
+          end
+
+          # Verifica se alguma mensagem falhou
+          failed_count = results.count { |r| r.is_a?(Hash) && !r[:success] }
+          if failed_count > 0
+            log_warn(
+              "Algumas mensagens falharam no processamento paralelo",
+              failed_count: failed_count,
+              total_count: messages.size
+            )
+          end
+
+          results
+        end
+
+        def process_single_message_with_timeout(sqs_msg, body, timeout)
+          ErrorHandler.with_timeout(timeout) do
+            ErrorHandler.handle_error(worker_name, sqs_msg) do
+              log_debug(
+                "Processando mensagem em thread",
+                message_id: sqs_msg.message_id,
+                thread_id: Thread.current.object_id
+              )
+
+              process_message(body)
+              { success: true, message_id: sqs_msg.message_id }
+            end
+          end
+        rescue Shoryuken::Template::TimeoutError => e
+          log_error(
+            "Timeout ao processar mensagem",
+            message_id: sqs_msg.message_id,
+            timeout: timeout
+          )
+          { success: false, error: e, message_id: sqs_msg.message_id }
+        rescue => e
+          { success: false, error: e, message_id: sqs_msg.message_id }
+        end
+
+        # Método que deve ser implementado pela classe filha
+        def process_message(body)
+          raise NotImplementedError, "Você deve implementar o método #process_message"
+        end
+      end
+    end
+  end
+end

data/lib/shoryuken/template/workers/standard_worker.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Shoryuken
+  module Template
+    module Workers
+      # Worker padrão - processa uma mensagem por vez
+      # 
+      # Exemplo de uso:
+      #   class MyWorker
+      #     include Shoryuken::Template::Workers::StandardWorker
+      #     
+      #     worker_options queue: 'my-queue'
+      #     
+      #     def process_message(body)
+      #       # Sua lógica aqui
+      #       puts "Processando: #{body}"
+      #     end
+      #   end
+      module StandardWorker
+        def self.included(base)
+          base.include BaseWorker
+        end
+
+        # Método perform do Shoryuken
+        def perform(sqs_msg, body)
+          log_info(
+            "Iniciando processamento de mensagem",
+            message_id: sqs_msg.message_id,
+            queue: sqs_msg.queue_url
+          )
+
+          ErrorHandler.handle_error(worker_name, sqs_msg) do
+            process_message(body)
+          end
+        end
+
+        # Método que deve ser implementado pela classe filha
+        def process_message(body)
+          raise NotImplementedError, "Você deve implementar o método #process_message"
+        end
+      end
+    end
+  end
+end

data/lib/shoryuken/template.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Shoryuken
+  module Template
+    class Error < StandardError; end
+  end
+end
+
+require_relative "template/version"
+require_relative "template/configuration"
+require_relative "template/logger"
+require_relative "template/error_handler"
+require_relative "template/workers/base_worker"
+require_relative "template/workers/standard_worker"
+require_relative "template/workers/parallel_worker"
+require_relative "template/workers/fifo_worker"

data/shoryuken.yml.example

@@ -0,0 +1,43 @@
+# Arquivo de configuração do Shoryuken
+# Copie para shoryuken.yml e configure de acordo com suas necessidades
+
+# AWS Credentials (ou use IAM roles no Heroku)
+aws:
+  region: us-east-1
+  # access_key_id: <%= ENV['AWS_ACCESS_KEY_ID'] %>
+  # secret_access_key: <%= ENV['AWS_SECRET_ACCESS_KEY'] %>
+
+# Concurrency
+concurrency: 10
+
+# Delay between polls (em segundos)
+delay: 0
+
+# Filas
+queues:
+  # Worker Padrão
+  - [orders-queue, 2]
+  
+  # Worker Paralelo (batch)
+  - [images-queue, 1]
+  
+  # Worker FIFO
+  - [transactions-queue.fifo, 1]
+
+# Timeout (em segundos)
+timeout: 25
+
+# Lifecycle events
+lifecycle_events_logger: structured
+
+# Log level
+logfile: log/shoryuken.log
+verbose: false
+
+# Workers
+# Certifique-se de que seus workers estão carregados
+require:
+  - ./config/environment.rb
+  - ./app/workers/order_processor_worker.rb
+  - ./app/workers/image_processor_worker.rb
+  - ./app/workers/transaction_worker.rb

data/sig/shoryuken/template.rbs

@@ -0,0 +1,6 @@
+module Shoryuken
+  module Template
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification
+name: shoryuken-template
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Ramon Andrade
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shoryuken
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.22'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.35'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.35'
+description: Gem template para projetos Shoryuken com suporte a workers padrão, paralelos
+  e FIFO, incluindo pool de threads configurável, logging estruturado e métricas
+email:
+- andrade.rmn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- CONTRIBUTING.md
+- INSTALLATION.md
+- LICENSE.txt
+- PUBLISHING.md
+- Procfile.example
+- QUICKSTART.md
+- README.md
+- RUBY_3.4_FEATURES.md
+- Rakefile
+- UPGRADE_GUIDE.md
+- examples/configuration_example.rb
+- examples/fifo_worker_example.rb
+- examples/heroku_setup.rb
+- examples/parallel_worker_example.rb
+- examples/standard_worker_example.rb
+- examples/worker_specific_config_example.rb
+- lib/shoryuken/template.rb
+- lib/shoryuken/template/configuration.rb
+- lib/shoryuken/template/error_handler.rb
+- lib/shoryuken/template/logger.rb
+- lib/shoryuken/template/version.rb
+- lib/shoryuken/template/workers/base_worker.rb
+- lib/shoryuken/template/workers/fifo_worker.rb
+- lib/shoryuken/template/workers/parallel_worker.rb
+- lib/shoryuken/template/workers/standard_worker.rb
+- shoryuken.yml.example
+- sig/shoryuken/template.rbs
+homepage: https://github.com/sousmile/shoryuken-template
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/sousmile/shoryuken-template
+  source_code_uri: https://github.com/sousmile/shoryuken-template
+  changelog_uri: https://github.com/sousmile/shoryuken-template/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.4
+specification_version: 4
+summary: Template estruturado para workers Shoryuken com processamento paralelo e
+  sequencial
+test_files: []