boring_services 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afc3d44acfb6c7fe4d741a643dc87d08b2b9ae371daa24a054dea6c25f6c6429
-  data.tar.gz: d2c240bdbfe39bf716ac2025e4f8249b01e3b5dceda5fa6766601aeca308abb0
+  metadata.gz: 156bb67ea987370602ed678f3d8a525f6eeae09dcbc2a3ae8ac23fa85b474ca4
+  data.tar.gz: 8ce1325011cac932711b77afed6a5d0307bebedaa4e52fc2b65d9a153daf2e91
 SHA512:
-  metadata.gz: 924f46cbdd506ecd7212bdd0836aa557f8e397986861f21f684f9d0e7a02d1ede2a627e1aca67adb11f4a7faf94ef207ca1dc4476c2e5768ee80ddc6420cd714
-  data.tar.gz: 180534ff00c723563bd8e09bd022d94e100cf9f2e864cfe561db2021d288cd2a818957fe9baef5436af267d69b5876df7c1e67560dc974ccb3036eea1891c65c
+  metadata.gz: 72bf5746276b30243a9b75b8091491afd3e58e5e8feac6b3a8f62bc7cafa8f9088d6d1f279f075b6f3f77d0f350017a4bf277e18a3ef4844d273293fb2f3b363
+  data.tar.gz: 07ac07fe8b309a06ff23ca77a7681aab03c77d8ecc0fac5e86e6723c999eb05976827e2bafdd072f7dfc0eef700c731329402a627b6ab64d2492983aaf6d125f

data/lib/boring_services/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'thor'
 
 module BoringServices
@@ -16,8 +18,7 @@ module BoringServices
     desc 'setup', 'Setup/install all services (alias for install)'
     def setup
       config = Configuration.load(options[:config], options[:environment])
-      installer = Installer.new(config)
-      installer.install_all
+      Installer.new(config).install_all
     rescue Error => e
       puts "Error: #{e.message}"
       exit 1
@@ -27,12 +28,7 @@ module BoringServices
     def install(service_name = nil)
       config = Configuration.load(options[:config], options[:environment])
       installer = Installer.new(config)
-
-      if service_name
-        installer.install_service(service_name)
-      else
-        installer.install_all
-      end
+      service_name ? installer.install_service(service_name) : installer.install_all
     rescue Error => e
       puts "Error: #{e.message}"
       exit 1
@@ -41,8 +37,7 @@ module BoringServices
     desc 'uninstall SERVICE', 'Uninstall a specific service'
     def uninstall(service_name)
       config = Configuration.load(options[:config], options[:environment])
-      installer = Installer.new(config)
-      installer.uninstall_service(service_name)
+      Installer.new(config).uninstall_service(service_name)
     rescue Error => e
       puts "Error: #{e.message}"
       exit 1
@@ -51,8 +46,7 @@ module BoringServices
     desc 'restart SERVICE', 'Restart a specific service'
     def restart(service_name)
       config = Configuration.load(options[:config], options[:environment])
-      installer = Installer.new(config)
-      installer.restart_service(service_name)
+      Installer.new(config).restart_service(service_name)
     rescue Error => e
       puts "Error: #{e.message}"
       exit 1
@@ -62,12 +56,7 @@ module BoringServices
     def reconfigure(service_name = nil)
       config = Configuration.load(options[:config], options[:environment])
       installer = Installer.new(config)
-
-      if service_name
-        installer.reconfigure_service(service_name)
-      else
-        installer.reconfigure_all
-      end
+      service_name ? installer.reconfigure_service(service_name) : installer.reconfigure_all
     rescue Error => e
       puts "Error: #{e.message}"
       exit 1
@@ -76,15 +65,12 @@ module BoringServices
     desc 'status', 'Check health status of all services'
     def status
       Configuration.load(options[:config], options[:environment])
-      results = BoringServices.status
-
-      results.each do |service_name, result|
+      BoringServices.status.each do |service_name, result|
         puts "\n#{service_name}: #{result[:status]}"
         next unless result[:hosts]
 
-        result[:hosts].each do |host, host_result|
-          status_icon = host_result[:running] ? '✓' : '✗'
-          puts "  #{status_icon} #{host}: #{host_result[:running] ? 'running' : 'stopped'}"
+        result[:hosts].each do |host_result|
+          print_host_status(service_name, host_result)
         end
       end
     rescue Error => e
@@ -96,5 +82,53 @@ module BoringServices
     def version
       puts "boring_services #{VERSION}"
     end
+
+    private
+
+    def print_host_status(service_name, host_result)
+      status_icon = host_result[:running] ? '✓' : '✗'
+      label = host_result[:label] || host_result[:host]
+      status_text = host_result[:running] ? 'running' : 'stopped'
+      puts "  #{status_icon} #{label}: #{status_text}"
+
+      return unless host_result[:stats]&.any?
+
+      case service_name
+      when 'redis' then print_redis_stats(host_result[:stats])
+      when 'memcached' then print_memcached_stats(host_result[:stats])
+      end
+    end
+
+    def print_redis_stats(stats)
+      memory = stats['used_memory_human'] || 'N/A'
+      max_memory = stats['maxmemory_human'] || 'N/A'
+      clients = stats['connected_clients'] || '0'
+      hit_rate = calculate_hit_rate(stats['keyspace_hits'], stats['keyspace_misses'])
+      puts "      memory: #{memory} / #{max_memory}, clients: #{clients}, hit rate: #{hit_rate}%"
+    end
+
+    def print_memcached_stats(stats)
+      bytes = format_bytes(stats['bytes']&.to_i || 0)
+      conns = stats['curr_connections'] || '0'
+      items = stats['curr_items'] || '0'
+      hit_rate = calculate_hit_rate(stats['get_hits'], stats['get_misses'])
+      puts "      memory: #{bytes}, connections: #{conns}, items: #{items}, hit rate: #{hit_rate}%"
+    end
+
+    def calculate_hit_rate(hits, misses)
+      hits = hits&.to_i || 0
+      misses = misses&.to_i || 0
+      total = hits + misses
+      total.positive? ? ((hits.to_f / total) * 100).round(1) : 0
+    end
+
+    def format_bytes(bytes)
+      return '0B' if bytes.zero?
+
+      units = %w[B KB MB GB]
+      exp = (Math.log(bytes) / Math.log(1024)).to_i
+      exp = [exp, units.length - 1].min
+      "#{(bytes.to_f / (1024**exp)).round(1)}#{units[exp]}"
+    end
   end
 end

data/lib/boring_services/health_checker.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 module BoringServices
   class HealthChecker
+    REDIS_INFO_KEYS = %w[used_memory_human connected_clients keyspace_hits keyspace_misses maxmemory_human].freeze
+
     attr_reader :config, :ssh_executor
 
     def initialize(config)
@@ -16,32 +20,91 @@ module BoringServices
     end
 
     def check_service(service)
-      service_name = service['name']
-      host = service['host']
-      return { status: 'no_host' } unless host
-
-      host_result = check_service_on_host(service_name, host)
+      hosts = extract_hosts(service)
+      return { status: 'no_host' } if hosts.empty?
 
+      host_results = hosts.map { |host_config| check_host(service['name'], host_config) }
       {
-        status: host_result[:running] ? 'healthy' : 'unhealthy',
-        host: host_result
+        status: host_results.all? { |r| r[:running] } ? 'healthy' : 'unhealthy',
+        hosts: host_results
       }
     end
 
     private
 
+    def extract_hosts(service)
+      return Array(service['hosts']) if service['hosts']
+      return [service['host']] if service['host']
+
+      []
+    end
+
+    def check_host(service_name, host_config)
+      host = host_config.is_a?(Hash) ? (host_config['host'] || host_config[:host]) : host_config
+      label = host_config.is_a?(Hash) ? (host_config['label'] || host_config[:label]) : nil
+
+      result = check_service_on_host(service_name, host)
+      result[:label] = label
+      result[:host] = host
+      result
+    end
+
     def check_service_on_host(service_name, host)
-      result = { running: false, message: '' }
+      systemd_service = service_name == 'redis' ? 'redis-server' : service_name
+      status_output = ssh_executor.systemd_status(systemd_service, host)
+      running = status_output.to_s.include?('active (running)')
 
+      result = { running: running, message: status_output.to_s }
+      result[:stats] = fetch_stats(service_name, host) if running
+      result
+    rescue StandardError => e
+      { running: false, message: e.message }
+    end
+
+    def fetch_stats(service_name, host)
+      case service_name
+      when 'redis' then get_redis_stats(host)
+      when 'memcached' then get_memcached_stats(host)
+      else {}
+      end
+    end
+
+    def get_redis_stats(host)
+      password = config.secrets['redis_password']
+      password_resolved = password ? Secrets.resolve(password) : nil
+
+      result = {}
       ssh_executor.execute_on_host(host) do
-        status_output = ssh_executor.systemd_status(service_name)
-        result[:running] = status_output.include?('active (running)')
-        result[:message] = status_output
+        args = ['redis-cli']
+        args += ['-a', password_resolved] if password_resolved
+        args << 'INFO'
+
+        info = capture(*args, raise_on_non_zero_exit: false)
+        info.to_s.each_line do |line|
+          key, value = line.strip.split(':')
+          result[key] = value if key && value && REDIS_INFO_KEYS.include?(key)
+        end
       end
+      result
+    rescue StandardError
+      {}
+    end
+
+    def get_memcached_stats(host)
+      result = {}
+      ssh_executor.execute_on_host(host) do
+        stats = capture(:bash, '-c', "echo 'stats' | nc localhost 11211", raise_on_non_zero_exit: false)
+        stats.to_s.each_line do |line|
+          parts = line.strip.split
+          next unless parts[0] == 'STAT' && parts.length >= 3
+          next unless %w[bytes curr_connections get_hits get_misses curr_items].include?(parts[1])
 
+          result[parts[1]] = parts[2]
+        end
+      end
       result
-    rescue StandardError => e
-      { running: false, message: e.message }
+    rescue StandardError
+      {}
     end
   end
 end

data/lib/boring_services/railtie.rb

@@ -5,6 +5,12 @@ begin
     class Railtie < Rails::Railtie
       railtie_name :boring_services
 
+      # Initialize service locator after Rails config is loaded
+      initializer 'boring_services.initialize' do
+        # Reset locator so it picks up the correct Rails environment
+        BoringServices.reset_locator!
+      end
+
       rake_tasks do
         load File.expand_path('../tasks/services.rake', __dir__)
       end

data/lib/boring_services/service_locator.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module BoringServices
+  class ServiceLocator
+    attr_reader :config
+
+    def initialize(config = nil)
+      @config = config || Configuration.load
+    end
+
+    # Get all hosts for a service
+    # Returns array of host hashes with :host, :private_ip, :label keys
+    def hosts_for(service_name)
+      service = config.service_config(service_name.to_s)
+      return [] unless service
+
+      normalize_hosts(service['hosts'] || [])
+    end
+
+    # Get the connection IP for a service by region/label
+    # Prefers private_ip, falls back to host
+    # Label matching: "redis-eu" matches region "eu", "redis-us" matches "us"
+    def host_for_region(service_name, region)
+      return nil if region.to_s.strip.empty?
+
+      hosts = hosts_for(service_name)
+      host_entry = hosts.find do |h|
+        label = h[:label].to_s.downcase
+        region_str = region.to_s.downcase
+        label == region_str || label.end_with?("-#{region_str}") || label.start_with?("#{region_str}-")
+      end
+
+      return nil unless host_entry
+
+      connection_ip(host_entry)
+    end
+
+    # Get the first available host for a service (prefers private_ip)
+    def primary_host(service_name)
+      hosts = hosts_for(service_name)
+      return nil if hosts.empty?
+
+      connection_ip(hosts.first)
+    end
+
+    # Get all connection IPs for a service (prefers private_ip for each)
+    def all_hosts(service_name)
+      hosts_for(service_name).map { |h| connection_ip(h) }
+    end
+
+    # Get port for a service
+    def port_for(service_name)
+      service = config.service_config(service_name.to_s)
+      service&.dig('port')
+    end
+
+    # Build a Redis URL for a region
+    def redis_url(region: nil, password: nil, db: 0)
+      host = region ? host_for_region('redis', region) : primary_host('redis')
+      return nil unless host
+
+      port = port_for('redis') || 6379
+      auth = password.to_s.empty? ? '' : ":#{password}@"
+      "redis://#{auth}#{host}:#{port}/#{db}"
+    end
+
+    # Build memcached connection string (host:port,host:port format)
+    def memcached_servers(region: nil)
+      hosts = if region
+                host = host_for_region('memcached', region)
+                host ? [host] : []
+              else
+                all_hosts('memcached')
+              end
+
+      return nil if hosts.empty?
+
+      port = port_for('memcached') || 11211
+      hosts.map { |h| "#{h}:#{port}" }.join(',')
+    end
+
+    private
+
+    # Normalize hosts array - handles both simple strings and hashes
+    def normalize_hosts(hosts)
+      hosts.map do |h|
+        if h.is_a?(Hash)
+          {
+            host: h['host'],
+            private_ip: h['private_ip'],
+            label: h['label']
+          }
+        else
+          { host: h.to_s, private_ip: nil, label: nil }
+        end
+      end
+    end
+
+    # Get connection IP - prefer private_ip if available
+    def connection_ip(host_entry)
+      ip = host_entry[:private_ip].to_s.strip
+      ip.empty? ? host_entry[:host] : ip
+    end
+  end
+end

data/lib/boring_services/services/memcached.rb

@@ -7,7 +7,7 @@ module BoringServices
           ssh_executor.install_package('memcached')
           configure_memcached
           ssh_executor.systemd_enable('memcached')
-          ssh_executor.systemd_start('memcached')
+          ssh_executor.systemd_restart('memcached')
         end
         rails_credentials_entry
       end

data/lib/boring_services/services/redis.rb

@@ -33,10 +33,12 @@ module BoringServices
         memory = memory_mb || 256
         listen_port = port || 6379
         password = resolve_secret('redis_password') if config.secrets['redis_password']
+        bind_address = private_ip.to_s.strip.empty? ? "0.0.0.0" : "127.0.0.1 #{private_ip}"
 
         config_content = <<~REDIS
-          bind 0.0.0.0
+          bind #{bind_address}
           port #{listen_port}
+          dir /var/lib/redis
           maxmemory #{memory}mb
           maxmemory-policy allkeys-lru
           appendonly yes
@@ -49,6 +51,10 @@ module BoringServices
         execute :sudo, :mv, '/tmp/redis.conf', '/etc/redis/redis.conf'
         execute :sudo, :chown, 'redis:redis', '/etc/redis/redis.conf'
         execute :sudo, :chmod, '640', '/etc/redis/redis.conf'
+
+        # Set vm.overcommit_memory for Redis background saves
+        execute :sudo, :sysctl, '-w', 'vm.overcommit_memory=1'
+        execute "echo 'vm.overcommit_memory = 1' | sudo tee -a /etc/sysctl.conf > /dev/null || true"
       end
     end
   end

data/lib/boring_services/ssh_executor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sshkit'
 require 'sshkit/dsl'
 
@@ -5,6 +7,9 @@ module BoringServices
   class SSHExecutor
     include SSHKit::DSL
 
+    DPKG_LOCK_MAX_WAIT = 300
+    DPKG_LOCK_INTERVAL = 10
+
     attr_reader :config
 
     def initialize(config)
@@ -35,7 +40,6 @@ module BoringServices
           execute :sudo, 'DEBIAN_FRONTEND=noninteractive', 'apt-get', 'install', '-y', package
         end
       else
-        # Called from within SSHKit context
         wait_for_dpkg_lock
         backend.execute :sudo, 'apt-get', 'update'
         backend.execute :sudo, 'DEBIAN_FRONTEND=noninteractive', 'apt-get', 'install', '-y', package
@@ -43,36 +47,23 @@ module BoringServices
     end
 
     def wait_for_dpkg_lock
-      # Wait for dpkg/apt locks to be released (e.g., unattended-upgrades)
-      max_wait = 300  # 5 minutes max
-      wait_interval = 10  # Check every 10 seconds
       elapsed = 0
 
       loop do
-        # Check if dpkg lock exists and is held by another process
-        lock_held = backend.test '[ -f /var/lib/dpkg/lock-frontend ]'
-
-        if lock_held
-          # Check if lock is actually held by checking fuser
-          processes = backend.capture(:sudo, :fuser, '/var/lib/dpkg/lock-frontend', '2>/dev/null', raise_on_non_zero_exit: false).strip
-
-          if processes.empty?
-            # Lock file exists but no process holding it - safe to proceed
-            break
-          end
-
-          if elapsed >= max_wait
-            puts "    ⚠ Warning: dpkg lock still held after #{max_wait}s, proceeding anyway..."
-            break
-          end
-
-          puts "    ⏳ Waiting for dpkg lock to be released (#{elapsed}s elapsed)..."
-          sleep wait_interval
-          elapsed += wait_interval
-        else
-          # No lock file - safe to proceed
+        break unless backend.test '[ -f /var/lib/dpkg/lock-frontend ]'
+
+        processes = backend.capture(:sudo, :fuser, '/var/lib/dpkg/lock-frontend', '2>/dev/null',
+                                    raise_on_non_zero_exit: false).strip
+        break if processes.empty?
+
+        if elapsed >= DPKG_LOCK_MAX_WAIT
+          puts "    ⚠ Warning: dpkg lock still held after #{DPKG_LOCK_MAX_WAIT}s, proceeding anyway..."
           break
         end
+
+        puts "    ⏳ Waiting for dpkg lock to be released (#{elapsed}s elapsed)..."
+        sleep DPKG_LOCK_INTERVAL
+        elapsed += DPKG_LOCK_INTERVAL
       end
     end
 
@@ -119,9 +110,7 @@ module BoringServices
 
     def systemd_start(service_name, host = nil)
       if host
-        execute_on_host(host) do
-          execute :sudo, 'systemctl', 'start', service_name
-        end
+        execute_on_host(host) { execute :sudo, 'systemctl', 'start', service_name }
       else
         backend.execute :sudo, 'systemctl', 'start', service_name
       end
@@ -129,9 +118,7 @@ module BoringServices
 
     def systemd_stop(service_name, host = nil)
       if host
-        execute_on_host(host) do
-          execute :sudo, 'systemctl', 'stop', service_name
-        end
+        execute_on_host(host) { execute :sudo, 'systemctl', 'stop', service_name }
       else
         backend.execute :sudo, 'systemctl', 'stop', service_name
       end
@@ -139,9 +126,7 @@ module BoringServices
 
     def systemd_restart(service_name, host = nil)
       if host
-        execute_on_host(host) do
-          execute :sudo, 'systemctl', 'restart', service_name
-        end
+        execute_on_host(host) { execute :sudo, 'systemctl', 'restart', service_name }
       else
         backend.execute :sudo, 'systemctl', 'restart', service_name
       end
@@ -149,9 +134,7 @@ module BoringServices
 
     def systemd_disable(service_name, host = nil)
       if host
-        execute_on_host(host) do
-          execute :sudo, 'systemctl', 'disable', service_name
-        end
+        execute_on_host(host) { execute :sudo, 'systemctl', 'disable', service_name }
       else
         backend.execute :sudo, 'systemctl', 'disable', service_name
       end
@@ -159,21 +142,28 @@ module BoringServices
 
     def systemd_status(service_name, host = nil)
       if host
-        result = nil
+        output = nil
         execute_on_host(host) do
-          result = capture :sudo, 'systemctl', 'status', service_name, raise_on_non_zero_exit: false
+          output = capture :sudo, 'systemctl', 'status', service_name, raise_on_non_zero_exit: false
         end
-        result
+        output
       else
         backend.capture :sudo, 'systemctl', 'status', service_name, raise_on_non_zero_exit: false
       end
     end
 
+    def capture_on_host(host, *args)
+      output = nil
+      execute_on_host(host) do
+        output = capture(*args, raise_on_non_zero_exit: false)
+      end
+      output
+    end
+
     private
 
     def backend
-      SSHKit::Backend.current ||
-        raise('SSHKit backend is not available. Provide a host or call within execute_on_host.')
+      SSHKit::Backend.current || raise(Error, 'SSHKit backend not available')
     end
 
     def setup_sshkit
@@ -195,12 +185,19 @@ module BoringServices
         target_host = host['host'] || host[:host]
         raise Error, 'Host entry missing host field' unless target_host
 
-        user = host['user'] || host[:user] || config.user
-        "#{user}@#{target_host}"
+        build_sshkit_host(target_host, host['user'] || host[:user])
       else
         host_string = host.to_s
-        host_string.include?('@') ? host_string : "#{config.user}@#{host_string}"
+        return SSHKit::Host.new(host_string) if host_string.include?('@')
+
+        build_sshkit_host(host_string, nil)
       end
     end
+
+    def build_sshkit_host(hostname, user)
+      sshkit_host = SSHKit::Host.new(hostname)
+      sshkit_host.user = user || config.user
+      sshkit_host
+    end
   end
 end

data/lib/boring_services/version.rb

@@ -1,3 +1,3 @@
 module BoringServices
-  VERSION = '0.2.0'.freeze
+  VERSION = '0.4.0'.freeze
 end

data/lib/boring_services.rb

@@ -5,6 +5,7 @@ require_relative 'boring_services/cli'
 require_relative 'boring_services/installer'
 require_relative 'boring_services/ssh_executor'
 require_relative 'boring_services/health_checker'
+require_relative 'boring_services/service_locator'
 
 require_relative 'boring_services/services/base'
 require_relative 'boring_services/services/memcached'
@@ -15,14 +16,68 @@ require_relative 'boring_services/services/nginx'
 module BoringServices
   class Error < StandardError; end
 
-  def self.root
-    File.expand_path('..', __dir__)
-  end
+  class << self
+    def root
+      File.expand_path('..', __dir__)
+    end
+
+    def status
+      config = Configuration.load
+      health_checker = HealthChecker.new(config)
+      health_checker.check_all
+    end
+
+    # Service locator instance (cached)
+    def locator
+      @locator ||= ServiceLocator.new
+    end
+
+    # Reset cached locator (useful for testing or config reload)
+    def reset_locator!
+      @locator = nil
+    end
+
+    # Convenience methods - delegate to locator
+
+    # Get Redis host for a region (e.g., "eu", "us")
+    def redis_host(region = nil)
+      region ? locator.host_for_region('redis', region) : locator.primary_host('redis')
+    end
+
+    # Get Redis port
+    def redis_port
+      locator.port_for('redis') || 6379
+    end
+
+    # Build Redis URL
+    def redis_url(region: nil, password: nil, db: 0)
+      locator.redis_url(region: region, password: password, db: db)
+    end
+
+    # Get Memcached host for a region
+    def memcached_host(region = nil)
+      region ? locator.host_for_region('memcached', region) : locator.primary_host('memcached')
+    end
+
+    # Get Memcached port
+    def memcached_port
+      locator.port_for('memcached') || 11211
+    end
+
+    # Get Memcached servers string (host:port,host:port)
+    def memcached_servers(region: nil)
+      locator.memcached_servers(region: region)
+    end
+
+    # Generic: get host for any service by region
+    def host_for(service, region = nil)
+      region ? locator.host_for_region(service, region) : locator.primary_host(service)
+    end
 
-  def self.status
-    config = Configuration.load
-    health_checker = HealthChecker.new(config)
-    health_checker.check_all
+    # Generic: get port for any service
+    def port_for(service)
+      locator.port_for(service)
+    end
   end
 end
 require 'stringio'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boring_services
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - BoringCache
@@ -127,6 +127,7 @@ files:
 - lib/boring_services/installer.rb
 - lib/boring_services/railtie.rb
 - lib/boring_services/secrets.rb
+- lib/boring_services/service_locator.rb
 - lib/boring_services/services/base.rb
 - lib/boring_services/services/haproxy.rb
 - lib/boring_services/services/memcached.rb
@@ -158,7 +159,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Deploy infrastructure services for Ruby & Rails apps
 test_files: []