natswork-server 0.0.1

data/lib/natswork/metrics.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module NatsWork
+  class Metrics
+    attr_reader :counters, :gauges, :histograms, :timers
+
+    def initialize
+      @counters = Concurrent::Hash.new(0)
+      @gauges = Concurrent::Hash.new(0)
+      @histograms = Concurrent::Hash.new { |h, k| h[k] = [] }
+      @timers = Concurrent::Hash.new { |h, k| h[k] = [] }
+
+      @collectors = []
+      @enabled = true
+    end
+
+    # Counter - always increasing value
+    def increment(metric, value = 1, tags = {})
+      return unless @enabled
+
+      key = metric_key(metric, tags)
+      @counters[key] += value
+
+      notify_collectors(:counter, metric, @counters[key], tags)
+    end
+
+    def counter(metric, tags = {})
+      @counters[metric_key(metric, tags)]
+    end
+
+    # Gauge - point-in-time value
+    def gauge(metric, value, tags = {})
+      return unless @enabled
+
+      key = metric_key(metric, tags)
+      @gauges[key] = value
+
+      notify_collectors(:gauge, metric, value, tags)
+    end
+
+    def get_gauge(metric, tags = {})
+      @gauges[metric_key(metric, tags)]
+    end
+
+    # Histogram - distribution of values
+    def histogram(metric, value, tags = {})
+      return unless @enabled
+
+      key = metric_key(metric, tags)
+      @histograms[key] << value
+
+      # Keep only last 1000 values to prevent memory bloat
+      @histograms[key] = @histograms[key].last(1000) if @histograms[key].size > 1000
+
+      notify_collectors(:histogram, metric, value, tags)
+    end
+
+    def histogram_stats(metric, tags = {})
+      values = @histograms[metric_key(metric, tags)]
+      return nil if values.empty?
+
+      sorted = values.sort
+      {
+        count: values.size,
+        min: sorted.first,
+        max: sorted.last,
+        mean: values.sum.to_f / values.size,
+        p50: percentile(sorted, 0.5),
+        p95: percentile(sorted, 0.95),
+        p99: percentile(sorted, 0.99)
+      }
+    end
+
+    # Timer - measure duration
+    def time(metric, tags = {})
+      return yield unless @enabled
+
+      start_time = Time.now
+      begin
+        result = yield
+        duration = (Time.now - start_time) * 1000 # milliseconds
+
+        key = metric_key(metric, tags)
+        @timers[key] << duration
+
+        # Keep only last 1000 values
+        @timers[key] = @timers[key].last(1000) if @timers[key].size > 1000
+
+        notify_collectors(:timer, metric, duration, tags)
+        result
+      rescue StandardError
+        duration = (Time.now - start_time) * 1000
+
+        key = metric_key(metric, tags)
+        @timers[key] << duration
+
+        # Keep only last 1000 values
+        @timers[key] = @timers[key].last(1000) if @timers[key].size > 1000
+
+        notify_collectors(:timer, metric, duration, tags.merge(status: 'error'))
+        raise
+      end
+    end
+
+    def timer_stats(metric, tags = {})
+      key = metric_key(metric, tags)
+      values = @timers[key]
+      return nil if values.empty?
+
+      histogram_stats_from_values(values)
+    end
+
+    # Add a metrics collector (e.g., StatsD, Prometheus)
+    def add_collector(collector)
+      @collectors << collector if collector.respond_to?(:collect)
+    end
+
+    def remove_collector(collector)
+      @collectors.delete(collector)
+    end
+
+    def enable!
+      @enabled = true
+    end
+
+    def disable!
+      @enabled = false
+    end
+
+    def reset!
+      @counters.clear
+      @gauges.clear
+      @histograms.clear
+      @timers.clear
+    end
+
+    def snapshot
+      {
+        counters: @counters.to_h,
+        gauges: @gauges.to_h,
+        histograms: @histograms.transform_values { |v| histogram_stats_from_values(v) },
+        timers: @timers.transform_values { |v| histogram_stats_from_values(v) }
+      }
+    end
+
+    private
+
+    def metric_key(metric, tags)
+      return metric if tags.empty?
+
+      tag_str = tags.sort.map { |k, v| "#{k}:#{v}" }.join(',')
+      "#{metric}{#{tag_str}}"
+    end
+
+    def percentile(sorted_values, pct)
+      return nil if sorted_values.empty?
+
+      index = (sorted_values.size * pct).ceil - 1
+      index = 0 if index.negative?
+      sorted_values[index]
+    end
+
+    def histogram_stats_from_values(values)
+      return nil if values.empty?
+
+      sorted = values.sort
+      {
+        count: values.size,
+        min: sorted.first,
+        max: sorted.last,
+        mean: values.sum.to_f / values.size,
+        p50: percentile(sorted, 0.5),
+        p95: percentile(sorted, 0.95),
+        p99: percentile(sorted, 0.99)
+      }
+    end
+
+    def notify_collectors(type, metric, value, tags)
+      @collectors.each do |collector|
+        collector.collect(type, metric, value, tags)
+      rescue StandardError => e
+        # Don't let collector errors break metrics collection
+        NatsWork::Logger.error('Metrics collector error', {
+                                 collector: collector.class.name,
+                                 error: e.message
+                               })
+      end
+    end
+
+    class << self
+      def global
+        @global ||= new
+      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
+
+  # Base class for metrics collectors
+  class MetricsCollector
+    def collect(type, metric, value, tags)
+      raise NotImplementedError, "#{self.class} must implement #collect"
+    end
+  end
+
+  # StatsD metrics collector
+  class StatsDCollector < MetricsCollector
+    def initialize(client)
+      @client = client
+    end
+
+    def collect(type, metric, value, tags)
+      metric_name = tags.empty? ? metric : "#{metric}.#{tags.map { |k, v| "#{k}_#{v}" }.join('.')}"
+
+      case type
+      when :counter
+        @client.increment(metric_name, value)
+      when :gauge
+        @client.gauge(metric_name, value)
+      when :histogram
+        @client.histogram(metric_name, value)
+      when :timer
+        @client.timing(metric_name, value)
+      end
+    rescue StandardError
+      # Log but don't raise
+    end
+  end
+end

data/lib/natswork/middleware.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module NatsWork
+  module Middleware
+    class Entry
+      attr_reader :klass, :args
+
+      def initialize(klass, args = [])
+        @klass = klass
+        @args = args
+      end
+
+      def build
+        @klass.new(*@args)
+      end
+    end
+
+    class MiddlewareChain
+      attr_reader :entries
+
+      def initialize
+        @entries = []
+      end
+
+      def add(klass, *args)
+        @entries << Entry.new(klass, args)
+      end
+
+      def remove(klass)
+        @entries.delete_if { |entry| entry.klass == klass }
+      end
+
+      def clear
+        @entries.clear
+      end
+
+      def invoke(job, message, &block)
+        chain = @entries.map(&:build)
+        traverse(chain, job, message, &block)
+      end
+
+      private
+
+      def traverse(chain, job, message, &block)
+        if chain.empty?
+          block.call
+        else
+          middleware = chain.shift
+          middleware.call(job, message) do
+            traverse(chain, job, message, &block)
+          end
+        end
+      end
+    end
+
+    # Built-in Middleware
+    class Logger
+      def initialize(logger: ::Logger.new($stdout))
+        @logger = logger
+      end
+
+      def call(job, message)
+        job_class = job.class.name
+        job_id = message['job_id']
+
+        @logger.info "Starting job #{job_class} (#{job_id})"
+        started_at = Time.now
+
+        begin
+          result = yield
+          elapsed = ((Time.now - started_at) * 1000).round(2)
+          @logger.info "Completed job #{job_class} (#{job_id}) in #{elapsed}ms"
+          result
+        rescue StandardError => e
+          elapsed = ((Time.now - started_at) * 1000).round(2)
+          @logger.error "Failed job #{job_class} (#{job_id}) after #{elapsed}ms: #{e.message}"
+          raise
+        end
+      end
+    end
+
+    class Timer
+      def call(_job, message)
+        started_at = Time.now
+
+        result = yield
+
+        completed_at = Time.now
+        message['started_at'] = started_at.iso8601
+        message['completed_at'] = completed_at.iso8601
+        message['execution_time'] = completed_at - started_at
+
+        result
+      end
+    end
+
+    class ErrorHandler
+      def initialize(on_error: nil)
+        @on_error = on_error
+      end
+
+      def call(job, message)
+        yield
+      rescue StandardError => e
+        message['error'] = {
+          'type' => e.class.name,
+          'message' => e.message
+        }
+
+        @on_error&.call(job, message, e)
+
+        raise
+      end
+    end
+
+    class Retry
+      def initialize(retry_handler:, connection: nil)
+        @retry_handler = retry_handler
+        @connection = connection
+      end
+
+      def call(_job, message)
+        yield
+      rescue StandardError => e
+        handle_error(message, e)
+        nil # Don't propagate error
+      end
+
+      private
+
+      def handle_error(message, error)
+        if @retry_handler.should_retry?(message)
+          @retry_handler.schedule_retry(@connection, message, error)
+        else
+          @retry_handler.send_to_dead_letter(@connection, message, error)
+        end
+      end
+    end
+  end
+end

data/lib/natswork/middleware_chain.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module NatsWork
+  module Server
+    class MiddlewareChain
+      def initialize
+        @entries = []
+      end
+
+      def add(middleware, *args)
+        @entries << [middleware, args]
+        self
+      end
+
+      def invoke(*args)
+        chain = @entries.map do |middleware, options|
+          middleware.new(*options)
+        end
+
+        traverse_chain = lambda do
+          if chain.empty?
+            yield if block_given?
+          else
+            chain.shift.call(*args, &traverse_chain)
+          end
+        end
+
+        traverse_chain.call
+      end
+
+      def clear
+        @entries.clear
+      end
+
+      def empty?
+        @entries.empty?
+      end
+    end
+  end
+end