tasker-engine 1.0.0

data/lib/generators/tasker/templates/metrics_subscriber_spec.rb.erb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe <%= class_name %>Subscriber do
+  let(:subscriber) { described_class.new }
+
+  describe 'subscription registration' do
+    it 'subscribes to the expected events' do
+<% if subscribed_events.any? -%>
+      expected_events = <%= subscribed_events.map { |e| "'#{e}'" }.join(', ') %>
+      expect(described_class.subscribed_events).to contain_exactly(<%= subscribed_events.map { |e| "'#{e}'" }.join(', ') %>)
+<% else -%>
+      # TODO: Test subscription to your specific events
+      # expect(described_class.subscribed_events).to contain_exactly('task.completed', 'task.failed')
+<% end -%>
+    end
+  end
+
+<% handler_methods.each do |method| -%>
+  describe '#<%= method[:method_name] %>' do
+<% if method[:event].include?('completed') -%>
+    let(:completion_event) do
+      {
+        task_id: 'task-123',
+        task_name: 'test_task',
+        execution_duration: 45.2,
+        total_steps: 3,
+        completed_steps: 3,
+        failed_steps: 0,
+        started_at: 2.minutes.ago,
+        completed_at: Time.current,
+        timestamp: Time.current
+      }
+    end
+
+    it 'records completion metrics' do
+      # Expect timing metrics to be recorded
+      expect(subscriber).to receive(:record_histogram)
+        .with('tasker.execution.duration', 45.2, anything)
+
+      expect(subscriber).to receive(:record_counter)
+        .with('tasker.completed', 1, anything)
+
+      expect(subscriber).to receive(:record_gauge)
+        .with('tasker.workflow.step_count', 3, anything)
+
+      subscriber.<%= method[:method_name] %>(completion_event)
+    end
+
+    it 'extracts correct timing metrics' do
+      allow(subscriber).to receive(:record_histogram)
+      allow(subscriber).to receive(:record_counter)
+      allow(subscriber).to receive(:record_gauge)
+
+      # Mock the helper method to test data extraction
+      expect(subscriber).to receive(:extract_timing_metrics).with(completion_event)
+        .and_call_original
+
+      timing = subscriber.send(:extract_timing_metrics, completion_event)
+      expect(timing[:execution_duration]).to eq(45.2)
+      expect(timing[:step_count]).to eq(3)
+
+      subscriber.<%= method[:method_name] %>(completion_event)
+    end
+
+    it 'generates appropriate tags' do
+      expected_tags = include('task:test_task', "environment:#{Rails.env}")
+
+      expect(subscriber).to receive(:record_histogram)
+        .with(anything, anything, expected_tags)
+
+      subscriber.<%= method[:method_name] %>(completion_event)
+    end
+
+<% elsif method[:event].include?('failed') -%>
+    let(:failure_event) do
+      {
+        task_id: 'task-456',
+        task_name: 'failed_task',
+        step_id: 'step-789',
+        step_name: 'failing_step',
+        error_message: 'Connection timeout',
+        exception_class: 'Net::TimeoutError',
+        attempt_number: 2,
+        retry_limit: 3,
+        retryable: true,
+        timestamp: Time.current
+      }
+    end
+
+    it 'records error metrics' do
+      # Expect error metrics to be recorded
+      expect(subscriber).to receive(:record_counter)
+        .with('tasker.errors', 1, include('error_type:timeout'))
+
+      expect(subscriber).to receive(:record_counter)
+        .with('tasker.retries', 1, include('attempt:2'))
+
+      expect(subscriber).to receive(:record_counter)
+        .with('tasker.error_types', 1, include('retryable:retryable'))
+
+      subscriber.<%= method[:method_name] %>(failure_event)
+    end
+
+    it 'categorizes error types correctly' do
+      allow(subscriber).to receive(:record_counter)
+
+      # Mock the helper method to test error categorization
+      expect(subscriber).to receive(:extract_error_metrics).with(failure_event)
+        .and_call_original
+
+      error = subscriber.send(:extract_error_metrics, failure_event)
+      expect(error[:error_type]).to eq('timeout')
+      expect(error[:is_retryable]).to be(true)
+      expect(error[:final_failure]).to be(false)
+
+      subscriber.<%= method[:method_name] %>(failure_event)
+    end
+
+    it 'tracks final failures when retries exhausted' do
+      final_failure_event = failure_event.merge(attempt_number: 3, retry_limit: 3)
+
+      expect(subscriber).to receive(:record_counter)
+        .with('tasker.final_failures', 1, anything)
+
+      subscriber.<%= method[:method_name] %>(final_failure_event)
+    end
+
+<% else -%>
+    let(:sample_event) do
+      {
+        task_id: 'task-123',
+        task_name: 'test_task',
+        timestamp: Time.current
+      }
+    end
+
+    it 'handles <%= method[:event] %> events' do
+      # TODO: Test specific behavior for <%= method[:event] %> events
+      expect { subscriber.<%= method[:method_name] %>(sample_event) }.not_to raise_error
+    end
+
+<% end -%>
+    it 'handles malformed events gracefully' do
+      malformed_event = { task_id: nil }
+
+      expect { subscriber.<%= method[:method_name] %>(malformed_event) }.not_to raise_error
+    end
+  end
+
+<% end -%>
+  describe 'metrics recording methods' do
+    describe '#record_completion_metrics' do
+      let(:timing) do
+        {
+          execution_duration: 30.5,
+          step_count: 5,
+          completed_steps: 4,
+          failed_steps: 1
+        }
+      end
+      let(:tags) { ['task:test_task', 'environment:test'] }
+
+      it 'records all completion metrics' do
+        expect(subscriber).to receive(:record_histogram)
+          .with('tasker.execution.duration', 30.5, tags)
+
+        expect(subscriber).to receive(:record_counter)
+          .with('tasker.completed', 1, tags)
+
+        expect(subscriber).to receive(:record_gauge)
+          .with('tasker.workflow.step_count', 5, tags)
+
+        expect(subscriber).to receive(:record_gauge)
+          .with('tasker.workflow.failed_steps', 1, tags)
+
+        expect(subscriber).to receive(:record_gauge)
+          .with('tasker.workflow.success_rate', 80.0, tags)
+
+        subscriber.send(:record_completion_metrics, timing, tags)
+      end
+    end
+
+    describe '#record_error_metrics' do
+      let(:error) do
+        {
+          error_type: 'timeout',
+          attempt_number: 2,
+          is_retryable: true,
+          final_failure: false
+        }
+      end
+      let(:tags) { ['task:test_task'] }
+
+      it 'records all error metrics' do
+        expected_error_tags = tags + ['error_type:timeout']
+
+        expect(subscriber).to receive(:record_counter)
+          .with('tasker.errors', 1, expected_error_tags)
+
+        expect(subscriber).to receive(:record_counter)
+          .with('tasker.retries', 1, tags + ['attempt:2'])
+
+        expect(subscriber).to receive(:record_counter)
+          .with('tasker.error_types', 1, tags + ['retryable:retryable'])
+
+        subscriber.send(:record_error_metrics, error, tags)
+      end
+    end
+
+    describe '#calculate_success_rate' do
+      it 'calculates correct success rate' do
+        expect(subscriber.send(:calculate_success_rate, 8, 2)).to eq(80.0)
+        expect(subscriber.send(:calculate_success_rate, 10, 0)).to eq(100.0)
+        expect(subscriber.send(:calculate_success_rate, 0, 5)).to eq(0.0)
+        expect(subscriber.send(:calculate_success_rate, 0, 0)).to eq(100.0)
+      end
+    end
+  end
+
+  describe 'metrics backend integration' do
+    describe '#record_histogram' do
+      it 'logs metrics when no backend configured' do
+        expect(Rails.logger).to receive(:info)
+          .with(match(/METRIC\[histogram\] test\.metric: 42\.5/))
+
+        subscriber.send(:record_histogram, 'test.metric', 42.5, ['tag:value'])
+      end
+    end
+
+    describe '#record_counter' do
+      it 'logs metrics when no backend configured' do
+        expect(Rails.logger).to receive(:info)
+          .with(match(/METRIC\[counter\] test\.counter: \+1/))
+
+        subscriber.send(:record_counter, 'test.counter', 1, ['tag:value'])
+      end
+    end
+
+    describe '#record_gauge' do
+      it 'logs metrics when no backend configured' do
+        expect(Rails.logger).to receive(:info)
+          .with(match(/METRIC\[gauge\] test\.gauge: 100/))
+
+        subscriber.send(:record_gauge, 'test.gauge', 100, ['tag:value'])
+      end
+    end
+
+    describe '#tags_to_labels' do
+      it 'converts tags to Prometheus labels' do
+        tags = ['environment:production', 'task:order_process', 'status:completed']
+        labels = subscriber.send(:tags_to_labels, tags)
+
+        expect(labels).to eq({
+          environment: 'production',
+          task: 'order_process',
+          status: 'completed'
+        })
+      end
+
+      it 'handles malformed tags gracefully' do
+        tags = ['malformed_tag', 'good:tag', '']
+        labels = subscriber.send(:tags_to_labels, tags)
+
+        expect(labels).to eq({ good: 'tag' })
+      end
+    end
+  end
+
+  describe 'BaseSubscriber helper integration' do
+    let(:event) do
+      {
+        task_id: 'task-123',
+        task_name: 'integration_test',
+        execution_duration: 25.7,
+        exception_class: 'Net::ReadTimeout',
+        attempt_number: 1,
+        retryable: true,
+        timestamp: Time.current
+      }
+    end
+
+    it 'uses extract_timing_metrics helper' do
+      timing = subscriber.send(:extract_timing_metrics, event)
+
+      expect(timing[:execution_duration]).to eq(25.7)
+      expect(timing).to have_key(:started_at)
+      expect(timing).to have_key(:step_count)
+    end
+
+    it 'uses extract_error_metrics helper' do
+      error = subscriber.send(:extract_error_metrics, event)
+
+      expect(error[:error_type]).to eq('timeout')
+      expect(error[:attempt_number]).to eq(1)
+      expect(error[:is_retryable]).to be(true)
+    end
+
+    it 'uses extract_metric_tags helper' do
+      tags = subscriber.send(:extract_metric_tags, event)
+
+      expect(tags).to include('task:integration_test')
+      expect(tags).to include("environment:#{Rails.env}")
+      expect(tags).to include('retryable:true')
+    end
+  end
+end

data/lib/generators/tasker/templates/omniauth_authenticator.rb.erb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+# OmniAuth authenticator for <%= class_name %>
+# Generated by: rails generate tasker:authenticator <%= file_name %> --type=omniauth
+#
+# This authenticator integrates with OmniAuth for OAuth/OpenID authentication.
+# Supports multiple authentication providers and session-based authentication.
+#
+# Configuration example:
+#   Tasker.configuration do |config|
+#     config.auth do |auth|
+#       auth.strategy = :custom
+#       auth.options = {
+#         authenticator_class: '<%= class_name %>Authenticator',
+#         user_finder_method: :find_by_provider_uid,
+#         user_class: '<%= user_model_class %>',
+#         failure_path: '/auth/failure'
+#       }
+#     end
+#   end
+
+class <%= class_name %>Authenticator
+  include Tasker::Authentication::Interface
+
+  def initialize(options = {})
+    @user_finder_method = options[:user_finder_method] || :find_by_provider_uid
+    @user_class = options[:user_class] || '<%= user_model_class %>'
+    @failure_path = options[:failure_path] || '/auth/failure'
+    @options = options
+  end
+
+  # Required: Authenticate the request, raise exception if fails
+  def authenticate!(controller)
+    unless authenticated?(controller)
+      # For HTML requests, redirect to auth provider
+      if controller.request.format.html?
+        controller.redirect_to(@failure_path)
+        return
+      else
+        # For API requests, raise authentication error
+        raise Tasker::Authentication::AuthenticationError,
+              'Authentication required. Please authenticate via OAuth provider.'
+      end
+    end
+    true
+  end
+
+  # Required: Get the current authenticated user
+  def current_user(controller)
+    return @current_user if defined?(@current_user)
+
+    @current_user = begin
+      # Try session-based user lookup first
+      if controller.session[:user_id]
+        find_user_by_id(controller.session[:user_id])
+      elsif controller.session[:omniauth_auth]
+        # If we have fresh OmniAuth data, use it
+        auth_data = controller.session[:omniauth_auth]
+        find_user_by_provider_data(auth_data)
+      else
+        nil
+      end
+    rescue StandardError => e
+      Rails.logger.debug "OmniAuth authentication failed: #{e.message}"
+      nil
+    end
+  end
+
+  # Optional: Check if user is authenticated
+  def authenticated?(controller)
+    current_user(controller).present?
+  end
+
+  # Optional: Configuration validation
+  def validate_configuration(options = {})
+    errors = []
+
+    # Check if OmniAuth is available
+    unless defined?(OmniAuth)
+      errors << 'OmniAuth gem is required for OmniauthAuthenticator'
+    end
+
+    # Validate user class
+    user_class = options[:user_class] || '<%= user_model_class %>'
+    begin
+      model = user_class.constantize
+
+      # Check if user finder method exists
+      finder_method = options[:user_finder_method] || :find_by_provider_uid
+      unless model.respond_to?(finder_method)
+        errors << "User model '#{user_class}' does not have '#{finder_method}' method"
+      end
+    rescue NameError
+      errors << "User class '#{user_class}' not found"
+    end
+
+    # Validate failure path
+    failure_path = options[:failure_path]
+    if failure_path.present? && !failure_path.is_a?(String)
+      errors << 'Failure path must be a string'
+    end
+
+    errors
+  end
+
+  private
+
+  attr_reader :user_finder_method, :user_class, :failure_path, :options
+
+  def find_user_by_id(user_id)
+    return nil unless user_id
+
+    user_model = @user_class.constantize
+    user_model.find_by(id: user_id)
+  rescue ActiveRecord::RecordNotFound, NoMethodError
+    nil
+  end
+
+  def find_user_by_provider_data(auth_data)
+    return nil unless auth_data
+
+    provider = auth_data['provider']
+    uid = auth_data['uid']
+    return nil unless provider && uid
+
+    user_model = @user_class.constantize
+    user_model.send(@user_finder_method, provider, uid)
+  rescue StandardError
+    nil
+  end
+
+  def user_model
+    @user_model ||= @user_class.constantize
+  end
+end

data/lib/generators/tasker/templates/omniauth_authenticator_spec.rb.erb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe <%= class_name %>Authenticator, type: :model do
+  let(:options) do
+    {
+      user_finder_method: :find_by_provider_uid,
+      user_class: '<%= user_model_class %>',
+      failure_path: '/auth/failure'
+    }
+  end
+
+  let(:authenticator) { described_class.new(options) }
+  let(:controller) { instance_double('ActionController::Base') }
+  let(:session) { {} }
+
+  before do
+    allow(controller).to receive(:session).and_return(session)
+  end
+
+  describe '#initialize' do
+    it 'sets configuration options' do
+      expect(authenticator.send(:user_finder_method)).to eq(:find_by_provider_uid)
+      expect(authenticator.send(:user_class)).to eq('<%= user_model_class %>')
+      expect(authenticator.send(:failure_path)).to eq('/auth/failure')
+    end
+
+    it 'uses default values when options are not provided' do
+      authenticator = described_class.new
+      expect(authenticator.send(:user_finder_method)).to eq(:find_by_provider_uid)
+      expect(authenticator.send(:user_class)).to eq('<%= user_model_class %>')
+      expect(authenticator.send(:failure_path)).to eq('/auth/failure')
+    end
+  end
+
+  describe '#current_user' do
+    let(:user_id) { 1 }
+    let(:user) { double('User', id: user_id) }
+
+    before do
+      # Mock the user model
+      user_model = double('UserModel')
+      allow('<%= user_model_class %>').to receive(:constantize).and_return(user_model)
+      allow(user_model).to receive(:find_by).with(id: user_id).and_return(user)
+      allow(user_model).to receive(:find_by_provider_uid).with('github', '12345').and_return(user)
+    end
+
+    context 'with user_id in session' do
+      before do
+        session[:user_id] = user_id
+      end
+
+      it 'returns the authenticated user' do
+        expect(authenticator.current_user(controller)).to eq(user)
+      end
+    end
+
+    context 'with omniauth_auth data in session' do
+      before do
+        session[:omniauth_auth] = {
+          'provider' => 'github',
+          'uid' => '12345'
+        }
+      end
+
+      it 'returns the authenticated user' do
+        expect(authenticator.current_user(controller)).to eq(user)
+      end
+    end
+
+    context 'with no authentication data' do
+      it 'returns nil' do
+        expect(authenticator.current_user(controller)).to be_nil
+      end
+    end
+
+    context 'when user lookup raises an error' do
+      before do
+        session[:user_id] = user_id
+        allow('<%= user_model_class %>').to receive(:constantize).and_raise(NameError, 'User class not found')
+      end
+
+      it 'returns nil' do
+        expect(authenticator.current_user(controller)).to be_nil
+      end
+    end
+  end
+
+  describe '#authenticate!' do
+    let(:request) { instance_double('ActionDispatch::Request') }
+
+    before do
+      allow(controller).to receive(:request).and_return(request)
+    end
+
+    context 'when user is authenticated' do
+      before do
+        allow(authenticator).to receive(:authenticated?).with(controller).and_return(true)
+      end
+
+      it 'returns true' do
+        expect(authenticator.authenticate!(controller)).to be true
+      end
+    end
+
+    context 'when user is not authenticated' do
+      before do
+        allow(authenticator).to receive(:authenticated?).with(controller).and_return(false)
+      end
+
+      context 'for HTML requests' do
+        before do
+          allow(request).to receive(:format).and_return(double('format', html?: true))
+          allow(controller).to receive(:redirect_to)
+        end
+
+        it 'redirects to failure path' do
+          expect(controller).to receive(:redirect_to).with('/auth/failure')
+          authenticator.authenticate!(controller)
+        end
+      end
+
+      context 'for API requests' do
+        before do
+          allow(request).to receive(:format).and_return(double('format', html?: false))
+        end
+
+        it 'raises AuthenticationError' do
+          expect do
+            authenticator.authenticate!(controller)
+          end.to raise_error(Tasker::Authentication::AuthenticationError, /Authentication required/)
+        end
+      end
+    end
+  end
+
+  describe '#validate_configuration' do
+    context 'with valid configuration' do
+      before do
+        stub_const('OmniAuth', double('OmniAuth'))
+        user_model = double('UserModel')
+        allow('<%= user_model_class %>').to receive(:constantize).and_return(user_model)
+        allow(user_model).to receive(:respond_to?).with(:find_by_provider_uid).and_return(true)
+      end
+
+      it 'returns no errors' do
+        errors = authenticator.validate_configuration(options)
+        expect(errors).to be_empty
+      end
+    end
+
+    context 'when OmniAuth is not available' do
+      before do
+        hide_const('OmniAuth')
+      end
+
+      it 'returns validation error' do
+        errors = authenticator.validate_configuration(options)
+        expect(errors).to include('OmniAuth gem is required for OmniauthAuthenticator')
+      end
+    end
+
+    context 'with invalid user class' do
+      let(:invalid_options) { options.merge(user_class: 'NonExistentUser') }
+
+      it 'returns validation error' do
+        errors = authenticator.validate_configuration(invalid_options)
+        expect(errors).to include(/not found/)
+      end
+    end
+
+    context 'when user model is missing finder method' do
+      before do
+        stub_const('OmniAuth', double('OmniAuth'))
+        user_model = double('UserModel')
+        allow('<%= user_model_class %>').to receive(:constantize).and_return(user_model)
+        allow(user_model).to receive(:respond_to?).with(:find_by_provider_uid).and_return(false)
+      end
+
+      it 'returns validation error' do
+        errors = authenticator.validate_configuration(options)
+        expect(errors).to include(/does not have 'find_by_provider_uid' method/)
+      end
+    end
+
+    context 'with invalid failure path type' do
+      let(:invalid_options) { options.merge(failure_path: 123) }
+
+      it 'returns validation error' do
+        errors = authenticator.validate_configuration(invalid_options)
+        expect(errors).to include('Failure path must be a string')
+      end
+    end
+  end
+end

data/lib/generators/tasker/templates/opentelemetry_initializer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# This is an example initializer showing how to set up OpenTelemetry with Tasker
+# Copy this file to config/initializers/opentelemetry.rb and customize as needed
+
+require 'opentelemetry/sdk'
+require 'opentelemetry-exporter-otlp'
+require 'opentelemetry/instrumentation/all'
+
+# Configure OpenTelemetry
+OpenTelemetry::SDK.configure do |c|
+  c.service_name = Tasker.configuration.telemetry.service_name
+
+  # Service version must be configured for instrumentation to work properly
+  c.service_version = 'v1.0.0'
+
+  # Configure OTLP exporter to send to local Jaeger
+  otlp_exporter = OpenTelemetry::Exporter::OTLP::Exporter.new(
+    endpoint: 'http://localhost:4318/v1/traces'
+  )
+
+  # Add the OTLP exporter
+  c.add_span_processor(
+    OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(otlp_exporter)
+  )
+
+  # Resource configuration
+  c.resource = OpenTelemetry::SDK::Resources::Resource.create({
+                                                                # Core service identification
+                                                                'service.name' => Tasker.configuration.telemetry.service_name,
+                                                                'service.version' => Tasker.configuration.telemetry.service_version,
+                                                                'service.framework' => 'tasker'
+                                                              })
+
+  # ✅ ENHANCED: PG instrumentation re-enabled after memory and connection management improvements
+  # Tasker v1.6+ includes fixes for:
+  # - Database connection pooling with ActiveRecord::Base.connection_pool.with_connection
+  # - Memory leak prevention with explicit futures.clear() calls
+  # - Batched concurrent processing (MAX_CONCURRENT_STEPS = 3) to prevent connection exhaustion
+  # - Proper error persistence ensuring no dangling database connections
+
+  # Use all auto-instrumentations except Faraday (which has a known bug)
+  # The Faraday instrumentation incorrectly passes Faraday::Response objects instead of status codes
+  # causing "undefined method `to_i' for #<Faraday::Response>" errors
+  #
+  # If you want to enable Faraday instrumentation, use:
+  # c.use_all
+  #
+  # For now, we exclude it to prevent API step handler failures:
+  faraday_config = { 'OpenTelemetry::Instrumentation::Faraday' => { enabled: false } }
+  c.use_all(faraday_config)
+end