natswork-server 0.0.1

data/lib/natswork/monitoring.rb

@@ -0,0 +1,397 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'socket'
+
+module NatsWork
+  module Monitoring
+    # Prometheus metrics exporter
+    class PrometheusExporter
+      def initialize(options = {})
+        @metrics = options[:metrics] || Metrics.global
+        @port = options[:port] || 9090
+        @path = options[:path] || '/metrics'
+        @server = nil
+      end
+
+      def start_server
+        require 'webrick'
+
+        @server = WEBrick::HTTPServer.new(
+          Port: @port,
+          Logger: WEBrick::Log.new('/dev/null'),
+          AccessLog: []
+        )
+
+        @server.mount_proc(@path) do |_req, res|
+          res['Content-Type'] = 'text/plain'
+          res.body = export_metrics
+        end
+
+        Thread.new { @server.start }
+      end
+
+      def stop_server
+        @server&.shutdown
+      end
+
+      def export_metrics
+        lines = []
+        snapshot = @metrics.snapshot
+
+        # Export counters
+        snapshot[:counters].each do |metric, value|
+          name, labels = parse_metric_name(metric)
+          lines << "# TYPE natswork_#{name} counter"
+          lines << "natswork_#{name}#{format_labels(labels)} #{value}"
+        end
+
+        # Export gauges
+        snapshot[:gauges].each do |metric, value|
+          name, labels = parse_metric_name(metric)
+          lines << "# TYPE natswork_#{name} gauge"
+          lines << "natswork_#{name}#{format_labels(labels)} #{value}"
+        end
+
+        # Export histograms
+        snapshot[:histograms].each do |metric, stats|
+          next unless stats
+
+          name, labels = parse_metric_name(metric)
+          lines << "# TYPE natswork_#{name} histogram"
+          lines << "natswork_#{name}_count#{format_labels(labels)} #{stats[:count]}"
+          lines << "natswork_#{name}_sum#{format_labels(labels)} #{stats[:count] * stats[:mean]}"
+
+          # Add percentiles as separate metrics
+          %w[50 95 99].each do |percentile|
+            pct_key = "p#{percentile}".to_sym
+            if stats[pct_key]
+              lines << "natswork_#{name}_percentile#{format_labels(labels.merge(percentile: percentile))} #{stats[pct_key]}"
+            end
+          end
+        end
+
+        "#{lines.join("\n")}\n"
+      end
+
+      private
+
+      def parse_metric_name(metric)
+        if metric.include?('{')
+          name, labels_str = metric.split('{', 2)
+          labels_str = labels_str.chomp('}')
+          labels = Hash[labels_str.split(',').map { |pair| pair.split(':', 2) }]
+          [name.tr('.', '_'), labels]
+        else
+          [metric.tr('.', '_'), {}]
+        end
+      end
+
+      def format_labels(labels)
+        return '' if labels.empty?
+
+        label_pairs = labels.map { |k, v| "#{k}=\"#{v}\"" }.join(',')
+        "{#{label_pairs}}"
+      end
+    end
+
+    # StatsD integration
+    class StatsDReporter
+      def initialize(host = 'localhost', port = 8125, prefix = 'natswork')
+        @host = host
+        @port = port
+        @prefix = prefix
+        @socket = UDPSocket.new
+      end
+
+      def report_counter(metric, value, tags = {})
+        send_metric("#{@prefix}.#{metric}", value, 'c', tags)
+      end
+
+      def report_gauge(metric, value, tags = {})
+        send_metric("#{@prefix}.#{metric}", value, 'g', tags)
+      end
+
+      def report_timer(metric, value, tags = {})
+        send_metric("#{@prefix}.#{metric}", value, 'ms', tags)
+      end
+
+      def report_histogram(metric, value, tags = {})
+        send_metric("#{@prefix}.#{metric}", value, 'h', tags)
+      end
+
+      def close
+        @socket.close
+      end
+
+      private
+
+      def send_metric(metric, value, type, tags = {})
+        tag_str = tags.empty? ? '' : "|##{tags.map { |k, v| "#{k}:#{v}" }.join(',')}"
+        message = "#{metric}:#{value}|#{type}#{tag_str}"
+
+        @socket.send(message, 0, @host, @port)
+      rescue StandardError => e
+        # Don't let StatsD errors break the application
+        warn "StatsD error: #{e.message}"
+      end
+    end
+
+    # New Relic custom metrics (simplified)
+    class NewRelicReporter
+      def initialize
+        @enabled = defined?(NewRelic::Agent)
+      end
+
+      def report_counter(metric, value, _tags = {})
+        return unless @enabled
+
+        NewRelic::Agent.record_metric("Custom/NatsWork/#{metric}", value)
+      end
+
+      def report_gauge(metric, value, _tags = {})
+        return unless @enabled
+
+        NewRelic::Agent.record_metric("Custom/NatsWork/#{metric}", value)
+      end
+
+      def report_timer(metric, value, _tags = {})
+        return unless @enabled
+
+        # Convert to seconds for New Relic
+        NewRelic::Agent.record_metric("Custom/NatsWork/#{metric}", value / 1000.0)
+      end
+    end
+
+    # Generic webhook reporter
+    class WebhookReporter
+      def initialize(webhook_url, options = {})
+        @webhook_url = webhook_url
+        @batch_size = options.fetch(:batch_size, 100)
+        @flush_interval = options.fetch(:flush_interval, 60)
+        @metrics_buffer = []
+        @mutex = Mutex.new
+
+        start_flush_timer
+      end
+
+      def report_metric(type, metric, value, tags = {})
+        @mutex.synchronize do
+          @metrics_buffer << {
+            type: type,
+            metric: metric,
+            value: value,
+            tags: tags,
+            timestamp: Time.now.to_f
+          }
+
+          flush_metrics if @metrics_buffer.size >= @batch_size
+        end
+      end
+
+      def report_counter(metric, value, tags = {})
+        report_metric('counter', metric, value, tags)
+      end
+
+      def report_gauge(metric, value, tags = {})
+        report_metric('gauge', metric, value, tags)
+      end
+
+      def report_timer(metric, value, tags = {})
+        report_metric('timer', metric, value, tags)
+      end
+
+      def flush_metrics
+        return if @metrics_buffer.empty?
+
+        metrics = @metrics_buffer.dup
+        @metrics_buffer.clear
+
+        # Send webhook asynchronously
+        Thread.new do
+          send_webhook(metrics)
+        end
+      end
+
+      private
+
+      def start_flush_timer
+        Thread.new do
+          loop do
+            sleep @flush_interval
+            @mutex.synchronize { flush_metrics }
+          end
+        end
+      end
+
+      def send_webhook(metrics)
+        {
+          timestamp: Time.now.iso8601,
+          hostname: Socket.gethostname,
+          metrics: metrics
+        }
+
+        # This would use an HTTP client in a real implementation
+        NatsWork::Logger.debug('Webhook metrics batch',
+                               url: @webhook_url,
+                               count: metrics.size)
+      end
+    end
+
+    # Monitoring coordinator that manages all reporters
+    class Coordinator
+      def initialize
+        @reporters = []
+        @enabled = true
+      end
+
+      def add_reporter(reporter)
+        @reporters << reporter
+      end
+
+      def remove_reporter(reporter)
+        @reporters.delete(reporter)
+      end
+
+      def report_counter(metric, value, tags = {})
+        return unless @enabled
+
+        @reporters.each do |reporter|
+          reporter.report_counter(metric, value, tags) if reporter.respond_to?(:report_counter)
+        end
+      end
+
+      def report_gauge(metric, value, tags = {})
+        return unless @enabled
+
+        @reporters.each do |reporter|
+          reporter.report_gauge(metric, value, tags) if reporter.respond_to?(:report_gauge)
+        end
+      end
+
+      def report_timer(metric, value, tags = {})
+        return unless @enabled
+
+        @reporters.each do |reporter|
+          reporter.report_timer(metric, value, tags) if reporter.respond_to?(:report_timer)
+        end
+      end
+
+      def report_histogram(metric, value, tags = {})
+        return unless @enabled
+
+        @reporters.each do |reporter|
+          reporter.report_histogram(metric, value, tags) if reporter.respond_to?(:report_histogram)
+        end
+      end
+
+      def enable!
+        @enabled = true
+      end
+
+      def disable!
+        @enabled = false
+      end
+
+      def shutdown
+        @reporters.each do |reporter|
+          reporter.close if reporter.respond_to?(:close)
+        end
+      end
+
+      class << self
+        def global
+          @global ||= new
+        end
+      end
+    end
+
+    # Monitoring setup helpers
+    module Setup
+      def self.prometheus(port: 9090, path: '/metrics')
+        exporter = PrometheusExporter.new(port: port, path: path)
+        exporter.start_server
+        Coordinator.global.add_reporter(exporter)
+        exporter
+      end
+
+      def self.statsd(host: 'localhost', port: 8125, prefix: 'natswork')
+        reporter = StatsDReporter.new(host, port, prefix)
+
+        # Wire up metrics to StatsD
+        metrics_collector = Class.new(MetricsCollector) do
+          define_method(:initialize) { @reporter = reporter }
+
+          define_method(:collect) do |type, metric, value, tags|
+            case type
+            when :counter then @reporter.report_counter(metric, value, tags)
+            when :gauge then @reporter.report_gauge(metric, value, tags)
+            when :timer then @reporter.report_timer(metric, value, tags)
+            when :histogram then @reporter.report_histogram(metric, value, tags)
+            end
+          end
+        end
+
+        Metrics.global.add_collector(metrics_collector.new)
+        reporter
+      end
+
+      def self.new_relic
+        reporter = NewRelicReporter.new
+        Coordinator.global.add_reporter(reporter)
+        reporter
+      end
+
+      def self.webhook(url, options = {})
+        reporter = WebhookReporter.new(url, options)
+        Coordinator.global.add_reporter(reporter)
+        reporter
+      end
+    end
+
+    # Built-in system metrics collector
+    class SystemMetrics
+      def initialize(metrics = nil)
+        @metrics = metrics || Metrics.global
+        @enabled = false
+      end
+
+      def start_collection(interval = 30)
+        return if @enabled
+
+        @enabled = true
+        @collection_thread = Thread.new do
+          while @enabled
+            collect_system_metrics
+            sleep interval
+          end
+        end
+      end
+
+      def stop_collection
+        @enabled = false
+        @collection_thread&.join
+      end
+
+      private
+
+      def collect_system_metrics
+        # Memory usage
+        if defined?(GC.stat)
+          memory_bytes = GC.stat(:heap_allocated_pages) * GC::INTERNAL_CONSTANTS[:HEAP_PAGE_SIZE]
+          @metrics.gauge('system.memory.used_bytes', memory_bytes)
+
+          @metrics.gauge('system.memory.gc.count', GC.count)
+          @metrics.gauge('system.memory.gc.heap_pages', GC.stat(:heap_allocated_pages))
+        end
+
+        # Process info
+        @metrics.gauge('system.process.pid', Process.pid)
+        @metrics.gauge('system.process.uptime', Time.now - $PROGRAM_START_TIME)
+
+        # Thread count
+        @metrics.gauge('system.threads.count', Thread.list.size)
+      end
+    end
+  end
+end