natswork-server 0.0.1

data/lib/natswork/instrumentation.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module NatsWork
+  module Instrumentation
+    extend self
+
+    # Event subscribers
+    @subscribers = Concurrent::Hash.new { |h, k| h[k] = Concurrent::Array.new }
+    @enabled = true
+
+    def subscribe(event, &block)
+      return unless block_given?
+
+      subscription = Subscription.new(event, block)
+      @subscribers[event.to_s] << subscription
+      subscription
+    end
+
+    def unsubscribe(subscription)
+      @subscribers.each_value { |subs| subs.delete(subscription) }
+    end
+
+    def instrument(event, payload = {})
+      return yield if block_given? && !@enabled
+
+      event_name = event.to_s
+      payload = payload.dup
+      payload[:event] = event_name
+      payload[:started_at] = Time.now
+
+      begin
+        if block_given?
+          result = yield
+          payload[:finished_at] = Time.now
+          payload[:duration] = (payload[:finished_at] - payload[:started_at]) * 1000
+          payload[:result] = result
+
+          notify_subscribers(event_name, payload)
+          result
+        else
+          notify_subscribers(event_name, payload)
+        end
+      rescue StandardError => e
+        payload[:finished_at] = Time.now
+        payload[:duration] = (payload[:finished_at] - payload[:started_at]) * 1000
+        payload[:error] = e
+        payload[:exception] = [e.class.name, e.message]
+
+        notify_subscribers("#{event_name}.error", payload)
+        notify_subscribers(event_name, payload)
+        raise
+      end
+    end
+
+    def enable!
+      @enabled = true
+    end
+
+    def disable!
+      @enabled = false
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    def clear_subscribers!
+      @subscribers.clear
+    end
+
+    private
+
+    def notify_subscribers(event, payload)
+      return unless @enabled
+
+      @subscribers[event].each do |subscription|
+        subscription.call(payload)
+      rescue StandardError => e
+        # Log but don't let subscriber errors break the flow
+        NatsWork::Logger.error('Instrumentation subscriber error',
+                               event: event,
+                               error: e.message)
+      end
+
+      # Also notify wildcard subscribers
+      @subscribers['*'].each do |subscription|
+        subscription.call(payload)
+      rescue StandardError => e
+        NatsWork::Logger.error('Wildcard instrumentation subscriber error',
+                               event: event,
+                               error: e.message)
+      end
+    end
+
+    class Subscription
+      attr_reader :event, :callback
+
+      def initialize(event, callback)
+        @event = event.to_s
+        @callback = callback
+      end
+
+      def call(payload)
+        @callback.call(payload)
+      end
+    end
+
+    # ActiveSupport::Notifications compatibility layer
+    module ActiveSupportCompatibility
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def instrument(event, payload = {}, &block)
+          if defined?(ActiveSupport::Notifications)
+            ActiveSupport::Notifications.instrument("natswork.#{event}", payload, &block)
+          else
+            NatsWork::Instrumentation.instrument(event, payload, &block)
+          end
+        end
+
+        def subscribe(pattern, &block)
+          if defined?(ActiveSupport::Notifications)
+            ActiveSupport::Notifications.subscribe(/^natswork\.#{pattern}/) do |name, started, finished, _id, payload|
+              payload[:event] = name.sub('natswork.', '')
+              payload[:started_at] = started
+              payload[:finished_at] = finished
+              payload[:duration] = (finished - started) * 1000 if finished && started
+              block.call(payload)
+            end
+          else
+            NatsWork::Instrumentation.subscribe(pattern, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/natswork/job_executor.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require_relative 'logger'
+require_relative 'metrics'
+require_relative 'instrumentation'
+require_relative 'health_check'
+
+module NatsWork
+  class JobExecutor
+    attr_reader :worker_name, :logger, :metrics
+
+    def initialize(worker_name, options = {})
+      @worker_name = worker_name
+      @logger = options[:logger] || Logger.new(namespace: "worker.#{worker_name}")
+      @metrics = options[:metrics] || Metrics.global
+      @middleware = options[:middleware] || []
+      @error_handlers = []
+      @job_filters = {
+        before: [],
+        after: [],
+        around: []
+      }
+      @skip_instrumentation = options[:skip_instrumentation] || false
+
+      setup_instrumentation unless @skip_instrumentation
+    end
+
+    def execute_job(job_message)
+      job_id = job_message['job_id']
+      job_class = job_message['job_class']
+      arguments = job_message['arguments'] || []
+
+      context = {
+        job_id: job_id,
+        job_class: job_class,
+        worker: @worker_name,
+        queue: job_message['queue'],
+        retry_count: job_message['retry_count'] || 0
+      }
+
+      filtered_args = filter_sensitive_data(arguments)
+
+      @logger.info('Starting job', context.merge(
+                                     arguments: filtered_args,
+                                     enqueued_at: job_message['created_at']
+                                   ))
+
+      @metrics.increment('jobs.started', 1,
+                         queue: job_message['queue'],
+                         job_class: job_class)
+
+      result = nil
+      start_time = Time.now
+
+      begin
+        # Instrument the job execution
+        Instrumentation.instrument('job.execute', context) do
+          # Run before filters
+          run_filters(:before, job_message, context)
+
+          # Execute the actual job
+          result = @metrics.time('job.execution_time',
+                                 queue: job_message['queue'],
+                                 job_class: job_class) do
+            perform_job(job_class, arguments)
+          end
+
+          # Run after filters
+          run_filters(:after, job_message, context.merge(result: result))
+
+          result
+        end
+
+        duration_ms = ((Time.now - start_time) * 1000).round(2)
+
+        @logger.info('Completed job', context.merge(
+                                        duration_ms: duration_ms,
+                                        result_class: result.class.name
+                                      ))
+
+        @metrics.increment('jobs.completed', 1,
+                           queue: job_message['queue'],
+                           job_class: job_class,
+                           status: 'success')
+
+        @metrics.histogram('job.duration', duration_ms,
+                           queue: job_message['queue'],
+                           job_class: job_class)
+
+        result
+      rescue StandardError => e
+        duration_ms = ((Time.now - start_time) * 1000).round(2)
+
+        error_context = context.merge(
+          duration_ms: duration_ms,
+          error_class: e.class.name,
+          error_message: e.message,
+          backtrace: e.backtrace&.first(10)
+        )
+
+        @logger.error('Job failed', error_context)
+
+        @metrics.increment('jobs.failed', 1,
+                           queue: job_message['queue'],
+                           job_class: job_class,
+                           error_class: e.class.name)
+
+        @metrics.histogram('job.duration', duration_ms,
+                           queue: job_message['queue'],
+                           job_class: job_class,
+                           status: 'error')
+
+        # Run error handlers
+        handle_job_error(e, job_message, context)
+
+        raise e
+      end
+    end
+
+    def add_middleware(middleware)
+      @middleware << middleware
+    end
+
+    def add_error_handler(&block)
+      @error_handlers << block if block_given?
+    end
+
+    def add_job_filter(type, &block)
+      @job_filters[type.to_sym] << block if block_given?
+    end
+
+    def on_job_retry(&block)
+      add_job_filter(:retry, &block)
+    end
+
+    def on_job_failure(&block)
+      add_error_handler(&block)
+    end
+
+    private
+
+    def setup_instrumentation
+      # Subscribe to job events for additional logging
+      Instrumentation.subscribe('job.execute') do |payload|
+        if payload[:error]
+          logger.error('Job instrumentation error',
+                       event: payload[:event],
+                       job_id: payload[:job_id],
+                       error: payload[:exception])
+        end
+      end
+
+      # Subscribe to metrics for health monitoring
+      Instrumentation.subscribe('job.execute.error') do |payload|
+        # Track error patterns
+        metrics.increment('errors.by_class', 1,
+                          error_class: payload[:exception]&.first,
+                          job_class: payload[:job_class])
+      end
+    end
+
+    def perform_job(job_class_name, arguments)
+      # This is where the actual job class would be instantiated and performed
+      # For now, simulate job execution
+      job_class = begin
+        Object.const_get(job_class_name)
+      rescue StandardError
+        nil
+      end
+
+      # Ensure arguments are symbolized if it's a hash
+      args = if arguments.is_a?(Hash)
+               arguments.transform_keys(&:to_sym)
+             elsif arguments.is_a?(Array) && arguments.length == 1 && arguments[0].is_a?(Hash)
+               # If single hash argument in array, extract and symbolize
+               arguments[0].transform_keys(&:to_sym)
+             else
+               arguments
+             end
+
+      if job_class.respond_to?(:perform_async)
+        # Handle NatsWork::Job classes
+        job_instance = job_class.new
+        job_instance.perform(args)
+      elsif job_class.respond_to?(:perform)
+        # Handle plain Ruby classes with perform method
+        job_class.perform(args)
+      else
+        raise ArgumentError, "Unknown job class or missing perform method: #{job_class_name}"
+      end
+    end
+
+    def run_filters(type, job_message, context)
+      @job_filters[type].each do |filter|
+        filter.call(job_message, context)
+      rescue StandardError => e
+        @logger.warn('Job filter error',
+                     filter_type: type,
+                     job_id: context[:job_id],
+                     error: e.message)
+      end
+    end
+
+    def handle_job_error(error, job_message, context)
+      @error_handlers.each do |handler|
+        handler.call(error, job_message, context)
+      rescue StandardError => e
+        @logger.error('Error handler failed',
+                      job_id: context[:job_id],
+                      handler_error: e.message)
+      end
+
+      # Emit error tracking event
+      Instrumentation.instrument('job.error', context.merge(
+                                                error: error,
+                                                error_class: error.class.name,
+                                                error_message: error.message
+                                              ))
+    end
+
+    def filter_sensitive_data(arguments)
+      # Filter out sensitive data from job arguments for logging
+      case arguments
+      when Hash
+        filter_hash(arguments)
+      when Array
+        arguments.map do |arg|
+          case arg
+          when Hash
+            filter_hash(arg)
+          when String
+            arg.length > 1000 ? "#{arg[0, 100]}...[truncated]" : arg
+          else
+            arg
+          end
+        end
+      else
+        arguments
+      end
+    end
+
+    def filter_hash(hash)
+      filtered = {}
+
+      hash.each do |key, value|
+        key_str = key.to_s.downcase
+
+        filtered[key] = if sensitive_key?(key_str)
+                          '[FILTERED]'
+                        elsif value.is_a?(Hash)
+                          filter_hash(value)
+                        elsif value.is_a?(String) && value.length > 1000
+                          "#{value[0, 100]}...[truncated]"
+                        else
+                          value
+                        end
+      end
+
+      filtered
+    end
+
+    def sensitive_key?(key)
+      sensitive_patterns = %w[
+        password passwd pass secret token key credential auth
+        ssn social_security credit_card cvv pin private_key
+      ]
+
+      sensitive_patterns.any? { |pattern| key.include?(pattern) }
+    end
+  end
+end

data/lib/natswork/job_hooks.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module NatsWork
+  class JobHooks
+    VALID_HOOKS = %i[before after retry failure success].freeze
+
+    class << self
+      def global
+        @global ||= new
+      end
+    end
+
+    def initialize
+      @hooks = {}
+      VALID_HOOKS.each { |hook| @hooks[hook] = [] }
+    end
+
+    def register(type, &block)
+      raise ArgumentError, "Invalid hook type: #{type}" unless VALID_HOOKS.include?(type)
+
+      @hooks[type] << block
+    end
+
+    def before(&block)
+      register(:before, &block)
+    end
+
+    def after(&block)
+      register(:after, &block)
+    end
+
+    def on_retry(&block)
+      register(:retry, &block)
+    end
+
+    def on_failure(&block)
+      register(:failure, &block)
+    end
+
+    def on_success(&block)
+      register(:success, &block)
+    end
+
+    def run(type, job, job_message, *args)
+      return unless @hooks[type]
+
+      @hooks[type].each do |hook|
+        hook.call(job, job_message, *args)
+      rescue StandardError
+        # Log error but don't fail job execution
+        # In production, use proper logging
+      end
+    end
+
+    def clear(type = nil)
+      if type
+        @hooks[type] = [] if @hooks[type]
+      else
+        @hooks.keys.each { |key| @hooks[key] = [] }
+      end
+    end
+  end
+end

data/lib/natswork/logger.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'json'
+require 'time'
+
+module NatsWork
+  class Logger
+    LEVELS = {
+      debug: ::Logger::DEBUG,
+      info: ::Logger::INFO,
+      warn: ::Logger::WARN,
+      error: ::Logger::ERROR,
+      fatal: ::Logger::FATAL
+    }.freeze
+
+    attr_reader :logger, :namespace, :structured
+
+    def initialize(options = {})
+      @namespace = options[:namespace] || 'natswork'
+      @structured = options.fetch(:structured, false)
+      @output = options[:output] || $stdout
+      @level = options[:level] || :info
+      @formatter = options[:formatter]
+
+      setup_logger
+    end
+
+    def debug(message, context = {}, &block)
+      log(:debug, message, context, &block)
+    end
+
+    def info(message, context = {}, &block)
+      log(:info, message, context, &block)
+    end
+
+    def warn(message, context = {}, &block)
+      log(:warn, message, context, &block)
+    end
+
+    def error(message, context = {}, &block)
+      log(:error, message, context, &block)
+    end
+
+    def fatal(message, context = {}, &block)
+      log(:fatal, message, context, &block)
+    end
+
+    def with_namespace(namespace)
+      self.class.new(
+        namespace: "#{@namespace}.#{namespace}",
+        structured: @structured,
+        output: @output,
+        level: @level,
+        formatter: @formatter
+      )
+    end
+
+    def level=(level)
+      @level = level
+      @logger.level = LEVELS[level] || ::Logger::INFO
+    end
+
+    private
+
+    def setup_logger
+      @logger = ::Logger.new(@output)
+      @logger.level = LEVELS[@level] || ::Logger::INFO
+
+      @logger.formatter = if @formatter
+                            @formatter
+                          elsif @structured
+                            method(:json_formatter)
+                          else
+                            method(:text_formatter)
+                          end
+    end
+
+    def log(level, message, context = {})
+      context = context.merge(
+        namespace: @namespace,
+        timestamp: Time.now.iso8601,
+        pid: Process.pid,
+        thread_id: Thread.current.object_id
+      )
+
+      if block_given?
+        start_time = Time.now
+        begin
+          result = yield
+          context[:duration] = ((Time.now - start_time) * 1000).round(2)
+          @logger.send(level, [message, context])
+          result
+        rescue StandardError => e
+          context[:duration] = ((Time.now - start_time) * 1000).round(2)
+          context[:error] = {
+            class: e.class.name,
+            message: e.message,
+            backtrace: e.backtrace&.first(10)
+          }
+          @logger.error([message, context])
+          raise
+        end
+      else
+        @logger.send(level, [message, context])
+      end
+    end
+
+    def json_formatter(severity, datetime, _progname, msg)
+      data = if msg.is_a?(Hash)
+               msg
+             elsif msg.is_a?(Array) && msg.size == 2
+               message, context = msg
+               context.merge(message: message)
+             else
+               { message: msg.to_s }
+             end
+
+      data[:severity] = severity
+      data[:time] = datetime.iso8601
+
+      "#{JSON.dump(data)}\n"
+    end
+
+    def text_formatter(severity, datetime, _progname, msg)
+      if msg.is_a?(Array) && msg.size == 2
+        message, context = msg
+        context_str = context.reject { |k, _| %i[namespace timestamp pid thread_id].include?(k) }
+                             .map { |k, v| "#{k}=#{v.inspect}" }
+                             .join(' ')
+
+        "[#{datetime.iso8601}] [#{severity}] [#{context[:namespace]}] #{message}#{context_str.empty? ? '' : " #{context_str}"}\n"
+      else
+        "[#{datetime.iso8601}] [#{severity}] [#{@namespace}] #{msg}\n"
+      end
+    end
+
+    class << self
+      def global
+        @global ||= new
+      end
+
+      def configure(options = {})
+        @global = new(options)
+      end
+
+      def method_missing(method, *args, &block)
+        if global.respond_to?(method)
+          global.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        global.respond_to?(method, include_private) || super
+      end
+    end
+  end
+
+  # LoggerProxy allows for lazy initialization and swappable loggers
+  class LoggerProxy
+    def initialize(target = nil)
+      @target = target
+    end
+
+    attr_writer :target
+
+    def method_missing(method, *args, &block)
+      target.send(method, *args, &block)
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      target.respond_to?(method, include_private) || super
+    end
+
+    private
+
+    def target
+      @target ||= Logger.global
+    end
+  end
+end