boring_services 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afc3d44acfb6c7fe4d741a643dc87d08b2b9ae371daa24a054dea6c25f6c6429
-  data.tar.gz: d2c240bdbfe39bf716ac2025e4f8249b01e3b5dceda5fa6766601aeca308abb0
+  metadata.gz: e386da541954a876687c37adade51199a571e5b75bc5583946a676a42a69e5e0
+  data.tar.gz: bb16f6517193ad18614eb91632c462e031856d06ac9d73abd25675698df50f43
 SHA512:
-  metadata.gz: 924f46cbdd506ecd7212bdd0836aa557f8e397986861f21f684f9d0e7a02d1ede2a627e1aca67adb11f4a7faf94ef207ca1dc4476c2e5768ee80ddc6420cd714
-  data.tar.gz: 180534ff00c723563bd8e09bd022d94e100cf9f2e864cfe561db2021d288cd2a818957fe9baef5436af267d69b5876df7c1e67560dc974ccb3036eea1891c65c
+  metadata.gz: 87986c7987ff4b9ee2490fe4ca8035ad536a90b571d2d9cdcf0d995c93a4e8d7e8c2836a2c4fa99fcf2137c1096aad91c166b300b1ff4a88df817220e29aaa51
+  data.tar.gz: ae84eb250c619ceb130e90db62fb4538939ee22755700e42231164f3c012ab67df397a5ad6f927534862827b346cf00f82b563b154a97ea698835f798275e8cc

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/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

@@ -37,6 +37,7 @@ module BoringServices
         config_content = <<~REDIS
           bind 0.0.0.0
           port #{listen_port}
+          dir /var/lib/redis
           maxmemory #{memory}mb
           maxmemory-policy allkeys-lru
           appendonly yes
@@ -49,6 +50,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.3.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boring_services
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - BoringCache
@@ -158,7 +158,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: []