natswork-client 0.0.1

data/lib/natswork/job.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'natswork/registry'
+
+module NatsWork
+  class Job
+    class << self
+      def inherited(subclass)
+        super
+        return unless subclass.name && !subclass.name.empty?
+
+        Registry.instance.register(
+          subclass.name,
+          subclass,
+          queue: subclass.instance_variable_get(:@queue) || 'default',
+          retries: subclass.instance_variable_get(:@retries),
+          timeout: subclass.instance_variable_get(:@timeout)
+        )
+      end
+
+      def queue(name = nil)
+        if name
+          @queue = name
+        else
+          @queue
+        end
+      end
+
+      def retries(count = nil)
+        if count
+          @retries = count
+        else
+          @retries
+        end
+      end
+
+      def timeout(seconds = nil)
+        if seconds
+          @timeout = seconds
+        else
+          @timeout
+        end
+      end
+
+      def get_queue
+        @queue || (superclass.respond_to?(:get_queue) && superclass.get_queue) || 'default'
+      end
+
+      def get_retries
+        @retries || (superclass.respond_to?(:get_retries) && superclass.get_retries) || 3
+      end
+
+      def get_timeout
+        @timeout || (superclass.respond_to?(:get_timeout) && superclass.get_timeout) || 30
+      end
+
+      def timeout_value
+        get_timeout
+      end
+
+      def perform_async(**args)
+        # Accept keyword arguments directly
+
+        Client.push(
+          job_class: name,
+          queue: get_queue,
+          max_retries: get_retries,
+          timeout: get_timeout,
+          arguments: args
+        )
+      end
+
+      def perform_sync(**args)
+        # Accept keyword arguments directly
+
+        Client.perform_sync(
+          job_class: name,
+          queue: get_queue,
+          max_retries: get_retries,
+          timeout: get_timeout,
+          arguments: args
+        )
+      end
+    end
+
+    attr_reader :job_id, :retry_count, :metadata
+    attr_accessor :context
+
+    def initialize
+      @job_id = nil
+      @retry_count = 0
+      @metadata = {}
+      @context = {}
+    end
+
+    def perform(*args)
+      raise NotImplementedError, "#{self.class} must implement #perform"
+    end
+  end
+end

data/lib/natswork/logging.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'json'
+
+module NatsWork
+  module Logging
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def logger
+        @logger ||= NatsWork.logger
+      end
+
+      def logger=(logger)
+        @logger = logger
+      end
+    end
+
+    def logger
+      self.class.logger
+    end
+
+    def log_debug(message, **context)
+      logger.debug(format_log_message(message, context))
+    end
+
+    def log_info(message, **context)
+      logger.info(format_log_message(message, context))
+    end
+
+    def log_warn(message, **context)
+      logger.warn(format_log_message(message, context))
+    end
+
+    def log_error(message, error = nil, **context)
+      if error
+        context[:error] = {
+          class: error.class.name,
+          message: error.message,
+          backtrace: error.backtrace&.first(5)
+        }
+      end
+
+      logger.error(format_log_message(message, context))
+    end
+
+    private
+
+    def format_log_message(message, context = {})
+      if logger.respond_to?(:formatter) && logger.formatter.is_a?(JSONFormatter)
+        context
+      else
+        msg = message.dup
+        msg += " | #{context.to_json}" unless context.empty?
+        msg
+      end
+    end
+  end
+
+  class JSONFormatter < ::Logger::Formatter
+    def call(severity, timestamp, progname, msg)
+      log_entry = {
+        timestamp: timestamp.utc.iso8601,
+        severity: severity,
+        progname: progname
+      }
+
+      if msg.is_a?(Hash)
+        log_entry.merge!(msg)
+      else
+        log_entry[:message] = msg
+      end
+
+      "#{log_entry.to_json}\n"
+    end
+  end
+
+  class << self
+    attr_writer :logger
+
+    def logger
+      @logger ||= begin
+        logger = ::Logger.new($stdout)
+        logger.level = ENV['NATSWORK_LOG_LEVEL'] ? ::Logger.const_get(ENV['NATSWORK_LOG_LEVEL'].upcase) : ::Logger::INFO
+        logger.progname = 'NatsWork'
+
+        logger.formatter = JSONFormatter.new if ENV['NATSWORK_LOG_FORMAT'] == 'json'
+
+        logger
+      end
+    end
+
+    def configure_logging(options = {})
+      if options[:logger]
+        self.logger = options[:logger]
+      else
+        output = options[:output] || $stdout
+        level = options[:level] || ::Logger::INFO
+        format = options[:format] || :text
+
+        self.logger = ::Logger.new(output)
+        logger.level = level
+        logger.progname = options[:progname] || 'NatsWork'
+
+        logger.formatter = JSONFormatter.new if format == :json
+      end
+    end
+  end
+
+  class LoggedConnection
+    include Logging
+
+    attr_reader :connection
+
+    def initialize(connection)
+      @connection = connection
+      setup_logging_callbacks
+    end
+
+    def connect
+      log_info 'Connecting to NATS', servers: @connection.servers
+      result = @connection.connect
+      log_info 'Connected to NATS successfully'
+      result
+    rescue StandardError => e
+      log_error 'Failed to connect to NATS', e, servers: @connection.servers
+      raise
+    end
+
+    def disconnect
+      log_info 'Disconnecting from NATS'
+      @connection.disconnect
+      log_info 'Disconnected from NATS'
+    end
+
+    def connected?
+      @connection.connected?
+    end
+
+    def publish(subject, payload)
+      log_debug 'Publishing message', subject: subject, payload_size: payload.to_s.bytesize
+      @connection.publish(subject, payload)
+    rescue StandardError => e
+      log_error 'Failed to publish message', e, subject: subject
+      raise
+    end
+
+    def subscribe(subject, opts = {}, &block)
+      log_info 'Subscribing to subject', subject: subject, options: opts
+
+      wrapped_block = proc do |msg, reply, subject, sid|
+        log_debug 'Received message', subject: subject, reply: reply
+        block.call(msg, reply, subject, sid)
+      rescue StandardError => e
+        log_error 'Error processing message', e, subject: subject
+        raise
+      end
+
+      sid = @connection.subscribe(subject, opts, &wrapped_block)
+      log_info 'Subscribed successfully', subject: subject, sid: sid
+      sid
+    rescue StandardError => e
+      log_error 'Failed to subscribe', e, subject: subject
+      raise
+    end
+
+    def request(subject, payload, opts = {})
+      log_debug 'Sending request', subject: subject, timeout: opts[:timeout]
+      start_time = Time.now
+
+      response = @connection.request(subject, payload, opts)
+
+      duration = Time.now - start_time
+      log_debug 'Received response', subject: subject, duration: duration
+
+      response
+    rescue NatsWork::TimeoutError
+      log_warn 'Request timed out', subject: subject, timeout: opts[:timeout]
+      raise
+    rescue StandardError => e
+      log_error 'Request failed', e, subject: subject
+      raise
+    end
+
+    def unsubscribe(sid)
+      log_debug 'Unsubscribing', sid: sid
+      @connection.unsubscribe(sid)
+      log_debug 'Unsubscribed successfully', sid: sid
+    end
+
+    def with_connection(&block)
+      @connection.with_connection(&block)
+    end
+
+    def jetstream
+      @connection.jetstream
+    end
+
+    def stats
+      @connection.stats
+    end
+
+    def healthy?
+      @connection.healthy?
+    end
+
+    def ping
+      result = @connection.ping
+      log_debug 'Ping result', success: result
+      result
+    end
+
+    # Delegate callback methods
+    def on_reconnect(&block)
+      @connection.on_reconnect(&block)
+    end
+
+    def on_disconnect(&block)
+      @connection.on_disconnect(&block)
+    end
+
+    def on_error(&block)
+      @connection.on_error(&block)
+    end
+
+    private
+
+    def setup_logging_callbacks
+      @connection.on_reconnect do
+        log_info 'Reconnected to NATS'
+      end
+
+      @connection.on_disconnect do
+        log_warn 'Disconnected from NATS'
+      end
+
+      @connection.on_error do |error|
+        log_error 'NATS connection error', error
+      end
+    end
+  end
+end

data/lib/natswork/message.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'securerandom'
+require 'time'
+require 'natswork/compression'
+
+module NatsWork
+  class Message
+    PROTOCOL_VERSION = '1.0.0'
+
+    TYPE_JOB_DISPATCH = 'job.dispatch'
+    TYPE_JOB_RESULT = 'job.result'
+    TYPE_JOB_ERROR = 'job.error'
+
+    VALID_TYPES = [
+      TYPE_JOB_DISPATCH,
+      TYPE_JOB_RESULT,
+      TYPE_JOB_ERROR
+    ].freeze
+
+    attr_accessor :type, :job_id, :job_class, :queue, :arguments,
+                  :retry_count, :max_retries, :timeout, :reply_to,
+                  :metadata, :created_at, :enqueued_at, :result, :error
+
+    def initialize(options = {})
+      @type = options[:type] || TYPE_JOB_DISPATCH
+      @job_id = options[:job_id] || SecureRandom.uuid
+      @job_class = options[:job_class]
+      @queue = options[:queue]
+      @arguments = options[:arguments] || []
+      @retry_count = options[:retry_count] || 0
+      @max_retries = options[:max_retries] || 3
+      @timeout = options[:timeout] || 30
+      @reply_to = options[:reply_to]
+      @metadata = options[:metadata] || {}
+      @created_at = options[:created_at] || Time.now.iso8601
+      @enqueued_at = options[:enqueued_at] || @created_at
+      @result = options[:result]
+      @error = options[:error]
+    end
+
+    def to_json(*args)
+      hash = to_hash
+
+      # Check if arguments should be compressed
+      if Compression.should_compress?(@arguments)
+        compression_result = Compression.compress(@arguments)
+        if compression_result[:compressed]
+          hash[:arguments] = compression_result[:data]
+          hash[:metadata] ||= {}
+          hash[:metadata]['compressed'] = true
+          hash[:metadata]['compression_ratio'] = Compression.compression_ratio(
+            compression_result[:original_size],
+            compression_result[:compressed_size]
+          )
+        end
+      end
+
+      hash.to_json(*args)
+    end
+
+    def to_hash
+      hash = {
+        type: @type,
+        job_id: @job_id,
+        job_class: @job_class,
+        queue: @queue,
+        arguments: @arguments,
+        retry_count: @retry_count,
+        max_retries: @max_retries,
+        timeout: @timeout,
+        metadata: @metadata,
+        created_at: @created_at,
+        enqueued_at: @enqueued_at,
+        protocol_version: PROTOCOL_VERSION
+      }
+
+      hash[:reply_to] = @reply_to if @reply_to
+      hash[:result] = @result if @result
+      hash[:error] = @error if @error
+
+      hash
+    end
+
+    def self.from_json(json_string)
+      begin
+        data = JSON.parse(json_string, symbolize_names: true)
+      rescue JSON::ParserError => e
+        raise InvalidMessageError, "Invalid JSON: #{e.message}"
+      end
+
+      if data[:protocol_version] && data[:protocol_version] != PROTOCOL_VERSION
+        major_version = data[:protocol_version].split('.').first
+        supported_major = PROTOCOL_VERSION.split('.').first
+
+        if major_version != supported_major
+          raise InvalidMessageError, "Unsupported protocol version: #{data[:protocol_version]}"
+        end
+      end
+
+      # Decompress arguments if compressed
+      if data[:metadata] && data[:metadata]['compressed']
+        compressed_payload = {
+          compressed: true,
+          data: data[:arguments]
+        }
+        data[:arguments] = Compression.decompress(compressed_payload)
+      end
+
+      new(data)
+    end
+
+    def valid?
+      return false unless @job_class && @queue
+      return false unless VALID_TYPES.include?(@type)
+
+      true
+    end
+
+    def validate!
+      raise InvalidMessageError, 'job_class is required' unless @job_class
+
+      raise InvalidMessageError, 'queue is required' unless @queue
+
+      raise InvalidMessageError, "Invalid message type: #{@type}" unless VALID_TYPES.include?(@type)
+
+      true
+    end
+  end
+end

data/lib/natswork/rails/console_helpers.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module NatsWork
+  module Rails
+    module ConsoleHelpers
+      module_function
+
+      # List all registered jobs
+      def jobs
+        Registry.instance.all_jobs
+      end
+
+      # Show jobs for a specific queue
+      def queue_jobs(queue_name)
+        Registry.instance.jobs_for_queue(queue_name)
+      end
+
+      # Show all queues
+      def queues
+        Registry.instance.all_queues
+      end
+
+      # Get client status
+      def status
+        client = Client.instance
+        pool = client.connection_pool
+
+        {
+          connected: pool&.healthy? || false,
+          pool_size: pool&.size || 0,
+          active_connections: pool&.active_connections || 0,
+          available_connections: pool&.available_connections || 0,
+          configuration: {
+            servers: client.configuration.servers,
+            namespace: client.configuration.namespace,
+            use_jetstream: client.configuration.use_jetstream
+          }
+        }
+      end
+
+      # Test job execution
+      def test_job(job_class, *args)
+        job = job_class.is_a?(Class) ? job_class : job_class.constantize
+        job_id = job.perform_async(*args)
+        puts "Job #{job_id} enqueued to queue '#{job.get_queue}'"
+        job_id
+      end
+
+      # Execute job synchronously (for testing)
+      def run_job(job_class, *args)
+        job = job_class.is_a?(Class) ? job_class : job_class.constantize
+        instance = job.new
+        result = instance.perform(*args)
+        puts "Job completed with result: #{result.inspect}"
+        result
+      end
+
+      # Check job result
+      def job_result(job_id)
+        Client.instance.job_status(job_id)
+      end
+
+      # Clear all results
+      def clear_results
+        client = Client.instance
+        count = client.instance_variable_get(:@result_store).size
+        client.instance_variable_set(:@result_store, {})
+        client.instance_variable_set(:@result_expiration_times, {})
+        puts "Cleared #{count} job results"
+      end
+
+      # Show scheduled jobs
+      def scheduled_jobs
+        Client.instance.instance_variable_get(:@scheduled_jobs).map do |job|
+          {
+            job_id: job[:message].job_id,
+            job_class: job[:message].job_class,
+            scheduled_for: job[:scheduled_for],
+            status: job[:status]
+          }
+        end
+      end
+
+      # Cancel a job
+      def cancel_job(job_id)
+        Client.instance.cancel_job(job_id)
+        puts "Cancellation message sent for job #{job_id}"
+        true
+      end
+
+      # Reconnect to NATS
+      def reconnect!
+        Client.instance.reset_connection!
+        puts 'Reconnected to NATS'
+        true
+      end
+
+      # Show connection pool statistics
+      def pool_stats
+        pool = Client.instance.connection_pool
+        pool&.stats || {}
+      end
+
+      # Enable/disable debug logging
+      def debug(enabled = true)
+        logger = enabled ? Logger.new($stdout) : nil
+        Client.instance.configuration.logger = logger
+        puts "Debug logging #{enabled ? 'enabled' : 'disabled'}"
+      end
+
+      # Perform a health check
+      def health_check
+        client = Client.instance
+        pool = client.connection_pool
+
+        if pool.nil?
+          puts '❌ Connection pool not initialized'
+          return false
+        end
+
+        healthy = pool.healthy?
+        puts healthy ? '✅ System healthy' : '❌ System unhealthy'
+
+        # Check individual connections
+        pool.with_connection do |conn|
+          if conn.connected?
+            puts '✅ NATS connection active'
+          else
+            puts '❌ NATS connection inactive'
+          end
+        end
+
+        healthy
+      rescue StandardError => e
+        puts "❌ Health check failed: #{e.message}"
+        false
+      end
+
+      # Show memory usage
+      def memory_usage
+        kb = `ps -o rss= -p #{Process.pid}`.to_i
+        mb = kb / 1024.0
+        puts "Memory usage: #{mb.round(2)} MB"
+        mb
+      end
+
+      # Benchmark job execution
+      def benchmark_job(job_class, *args, count: 100)
+        job = job_class.is_a?(Class) ? job_class : job_class.constantize
+
+        require 'benchmark'
+
+        time = Benchmark.realtime do
+          count.times do
+            job.perform_async(*args)
+          end
+        end
+
+        rate = count / time
+        puts "Enqueued #{count} jobs in #{time.round(3)} seconds"
+        puts "Rate: #{rate.round(2)} jobs/second"
+
+        { time: time, count: count, rate: rate }
+      end
+    end
+  end
+end
+
+# Make helpers available in Rails console
+if defined?(Rails::Console)
+  module Rails
+    class Console
+      include NatsWork::Rails::ConsoleHelpers
+    end
+  end
+
+  # Also make them available as top-level methods
+  include NatsWork::Rails::ConsoleHelpers
+
+  puts "NatsWork console helpers loaded. Type 'natswork_help' for available commands."
+
+  def natswork_help
+    puts <<~HELP
+      NatsWork Console Helpers:
+
+      jobs              - List all registered jobs
+      queue_jobs(name)  - Show jobs for a specific queue
+      queues            - Show all queues
+      status            - Get client status
+
+      test_job(class, *args)  - Enqueue a job
+      run_job(class, *args)   - Run a job synchronously
+      job_result(id)          - Check job result
+      cancel_job(id)          - Cancel a job
+
+      scheduled_jobs    - Show scheduled jobs
+      clear_results     - Clear all job results
+
+      reconnect!        - Reconnect to NATS
+      pool_stats        - Show connection pool stats
+      health_check      - Perform health check
+      memory_usage      - Show memory usage
+
+      debug(enabled)    - Enable/disable debug logging
+      benchmark_job(class, *args, count: 100) - Benchmark job execution
+    HELP
+  end
+end