server_stats 0.1.0

data/lib/server_stats/formatter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ServerStats
+  module Formatter
+    UNITS = %w[B KB MB GB TB PB].freeze
+
+    module_function
+
+    # Format bytes to human readable string (e.g. 1073741824 -> "1.00 GB")
+    def bytes_to_human(bytes, precision = 2)
+      return "0 B" if bytes.nil? || bytes <= 0
+
+      value = bytes.to_f
+      unit_index = 0
+
+      while value >= 1024.0 && unit_index < UNITS.size - 1
+        value /= 1024.0
+        unit_index += 1
+      end
+
+      if unit_index.zero?
+        "#{bytes} B"
+      else
+        "#{format("%.#{precision}f", value)} #{UNITS[unit_index]}"
+      end
+    end
+
+    # Format seconds to human readable string (e.g. 90061 -> "1d 1h 1m 1s")
+    def seconds_to_human(total_seconds)
+      return "0s" if total_seconds.nil? || total_seconds <= 0
+
+      secs = total_seconds.to_i
+      days = secs / 86_400
+      hours = (secs % 86_400) / 3600
+      minutes = (secs % 3600) / 60
+      seconds = secs % 60
+
+      parts = []
+      parts << "#{days}d" if days.positive?
+      parts << "#{hours}h" if hours.positive?
+      parts << "#{minutes}m" if minutes.positive?
+      parts << "#{seconds}s" if seconds.positive? || parts.empty?
+
+      parts.join(" ")
+    end
+
+    # Format percentage with standard precision
+    def format_percent(percent, precision = 2)
+      return "0.0%" if percent.nil?
+
+      "#{format("%.#{precision}f", percent)}%"
+    end
+  end
+end

data/lib/server_stats/models.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require_relative "formatter"
+
+module ServerStats
+  class CpuStats
+    attr_reader :cores, :physical_cores, :usage_percent, :load_average, :model
+
+    def initialize(cores:, usage_percent:, load_average: {}, physical_cores: nil, model: nil)
+      @cores = cores
+      @usage_percent = usage_percent ? usage_percent.round(2) : 0.0
+      @load_average = load_average || {}
+      @physical_cores = physical_cores || cores
+      @model = model
+    end
+
+    def to_h
+      {
+        cores: @cores,
+        physical_cores: @physical_cores,
+        usage_percent: @usage_percent,
+        load_average: @load_average,
+        model: @model
+      }
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+  end
+
+  class MemoryStats
+    attr_reader :total_bytes, :free_bytes, :available_bytes, :used_bytes,
+                :usage_percent, :details
+
+    def initialize(total_bytes:, free_bytes:, available_bytes: nil, used_bytes: nil, details: {})
+      @total_bytes = total_bytes.to_i
+      @free_bytes = free_bytes.to_i
+      @available_bytes = (available_bytes || free_bytes).to_i
+      @used_bytes = (used_bytes || [@total_bytes - @available_bytes, 0].max).to_i
+      @usage_percent = if @total_bytes.positive?
+                         ((@used_bytes.to_f / @total_bytes) * 100.0).round(2)
+                       else
+                         0.0
+                       end
+      @details = details || {}
+    end
+
+    def total_human
+      Formatter.bytes_to_human(@total_bytes)
+    end
+
+    def free_human
+      Formatter.bytes_to_human(@free_bytes)
+    end
+
+    def available_human
+      Formatter.bytes_to_human(@available_bytes)
+    end
+
+    def used_human
+      Formatter.bytes_to_human(@used_bytes)
+    end
+
+    def to_h
+      {
+        total_bytes: @total_bytes,
+        free_bytes: @free_bytes,
+        available_bytes: @available_bytes,
+        used_bytes: @used_bytes,
+        usage_percent: @usage_percent,
+        total_human: total_human,
+        free_human: free_human,
+        available_human: available_human,
+        used_human: used_human,
+        details: @details
+      }
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+  end
+
+  class DiskStats
+    attr_reader :path, :filesystem, :total_bytes, :used_bytes, :free_bytes,
+                :available_bytes, :usage_percent
+
+    def initialize(path:, filesystem:, total_bytes:, used_bytes:, available_bytes:, free_bytes: nil)
+      @path = path
+      @filesystem = filesystem
+      @total_bytes = total_bytes.to_i
+      @used_bytes = used_bytes.to_i
+      @available_bytes = available_bytes.to_i
+      @free_bytes = (free_bytes || available_bytes).to_i
+      @usage_percent = if @total_bytes.positive?
+                         ((@used_bytes.to_f / @total_bytes) * 100.0).round(2)
+                       else
+                         0.0
+                       end
+    end
+
+    def total_human
+      Formatter.bytes_to_human(@total_bytes)
+    end
+
+    def free_human
+      Formatter.bytes_to_human(@free_bytes)
+    end
+
+    def available_human
+      Formatter.bytes_to_human(@available_bytes)
+    end
+
+    def used_human
+      Formatter.bytes_to_human(@used_bytes)
+    end
+
+    def to_h
+      {
+        path: @path,
+        filesystem: @filesystem,
+        total_bytes: @total_bytes,
+        used_bytes: @used_bytes,
+        free_bytes: @free_bytes,
+        available_bytes: @available_bytes,
+        usage_percent: @usage_percent,
+        total_human: total_human,
+        used_human: used_human,
+        free_human: free_human,
+        available_human: available_human
+      }
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+  end
+
+  class SystemStats
+    attr_reader :os, :os_family, :os_version, :hostname, :architecture,
+                :kernel, :uptime_seconds
+
+    def initialize(os:, os_family:, os_version:, hostname:, architecture:, kernel:, uptime_seconds:)
+      @os = os
+      @os_family = os_family
+      @os_version = os_version
+      @hostname = hostname
+      @architecture = architecture
+      @kernel = kernel
+      @uptime_seconds = uptime_seconds.to_i
+    end
+
+    def uptime_human
+      Formatter.seconds_to_human(@uptime_seconds)
+    end
+
+    def to_h
+      {
+        os: @os,
+        os_family: @os_family,
+        os_version: @os_version,
+        hostname: @hostname,
+        architecture: @architecture,
+        kernel: @kernel,
+        uptime_seconds: @uptime_seconds,
+        uptime_human: uptime_human
+      }
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+  end
+
+  class Snapshot
+    attr_reader :cpu, :memory, :disk, :system, :timestamp
+
+    def initialize(cpu:, memory:, disk:, system:, timestamp: nil)
+      @cpu = cpu
+      @memory = memory
+      @disk = disk
+      @system = system
+      @timestamp = timestamp || Time.now.utc.iso8601
+    end
+
+    alias ram memory
+
+    def to_h
+      {
+        timestamp: @timestamp,
+        system: @system&.to_h,
+        cpu: @cpu&.to_h,
+        memory: @memory&.to_h,
+        disk: @disk&.to_h
+      }
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+  end
+end

data/lib/server_stats/os.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module ServerStats
+  module OS
+    module_function
+
+    def host_os
+      RbConfig::CONFIG["host_os"]
+    end
+
+    def macos?
+      /darwin|mac os/i.match?(host_os)
+    end
+
+    def linux?
+      /linux/i.match?(host_os)
+    end
+
+    def type
+      if macos?
+        :macos
+      elsif linux?
+        :linux
+      else
+        :unknown
+      end
+    end
+  end
+end

data/lib/server_stats/providers/base.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "open3"
+require "socket"
+require "etc"
+require "shellwords"
+require_relative "../models"
+
+module ServerStats
+  module Providers
+    class Base
+      # Execute command safely without raising exception
+      def execute(command)
+        stdout, _stderr, status = Open3.capture3(command)
+        return stdout.strip if status.success?
+
+        ""
+      rescue StandardError
+        ""
+      end
+
+      # Cross-platform disk stats using POSIX `df -P -k <path>`
+      def disk_stats(path = "/")
+        clean_path = path.to_s.strip
+        clean_path = "/" if clean_path.empty?
+
+        output = execute("df -P -k #{clean_path.shellescape}")
+        lines = output.lines.map(&:strip).reject(&:empty?)
+
+        if lines.size >= 2
+          # Skip header line, parse first data line
+          parts = lines[1].split(/\s+/)
+          filesystem = parts[0]
+          total_kb = parts[1].to_i
+          used_kb = parts[2].to_i
+          available_kb = parts[3].to_i
+
+          total_bytes = total_kb * 1024
+          used_bytes = used_kb * 1024
+          available_bytes = available_kb * 1024
+
+          DiskStats.new(
+            path: clean_path,
+            filesystem: filesystem,
+            total_bytes: total_bytes,
+            used_bytes: used_bytes,
+            available_bytes: available_bytes,
+            free_bytes: available_bytes
+          )
+        else
+          DiskStats.new(
+            path: clean_path,
+            filesystem: "unknown",
+            total_bytes: 0,
+            used_bytes: 0,
+            available_bytes: 0,
+            free_bytes: 0
+          )
+        end
+      end
+
+      # Logical CPU core count via Ruby's standard Etc
+      def cpu_cores
+        Etc.nprocessors
+      rescue StandardError
+        1
+      end
+
+      # Hostname helper
+      def hostname
+        Socket.gethostname
+      rescue StandardError
+        "localhost"
+      end
+
+      # Abstract methods to be implemented by OS providers
+      def cpu(_interval = 0.5)
+        raise NotImplementedError
+      end
+
+      def memory
+        raise NotImplementedError
+      end
+
+      def disk(path = "/")
+        disk_stats(path)
+      end
+
+      def system
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/server_stats/providers/linux.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ServerStats
+  module Providers
+    class Linux < Base
+      attr_accessor :proc_meminfo_path, :proc_stat_path, :proc_loadavg_path,
+                    :proc_uptime_path, :proc_cpuinfo_path, :os_release_path
+
+      def initialize(options = {})
+        super()
+        @proc_meminfo_path = options[:proc_meminfo_path] || "/proc/meminfo"
+        @proc_stat_path    = options[:proc_stat_path]    || "/proc/stat"
+        @proc_loadavg_path = options[:proc_loadavg_path] || "/proc/loadavg"
+        @proc_uptime_path  = options[:proc_uptime_path]  || "/proc/uptime"
+        @proc_cpuinfo_path = options[:proc_cpuinfo_path] || "/proc/cpuinfo"
+        @os_release_path   = options[:os_release_path]   || "/etc/os-release"
+      end
+
+      # Collect CPU statistics on Linux
+      def cpu(interval = 0.5)
+        cores = cpu_cores
+        model, physical_cores = parse_cpuinfo
+        load_avg = parse_load_average
+        usage_pct = calculate_cpu_usage(interval.to_f)
+
+        CpuStats.new(
+          cores: cores,
+          physical_cores: physical_cores || cores,
+          usage_percent: usage_pct,
+          load_average: load_avg,
+          model: model
+        )
+      end
+
+      # Collect Memory statistics on Linux
+      def memory
+        meminfo = parse_meminfo
+
+        total_bytes     = (meminfo["MemTotal"] || 0) * 1024
+        free_bytes      = (meminfo["MemFree"] || 0) * 1024
+        buffers_bytes   = (meminfo["Buffers"] || 0) * 1024
+        cached_bytes    = (meminfo["Cached"] || 0) * 1024
+        available_kb    = meminfo["MemAvailable"]
+
+        available_bytes = if available_kb
+                            available_kb * 1024
+                          else
+                            free_bytes + buffers_bytes + cached_bytes
+                          end
+
+        used_bytes = [total_bytes - available_bytes, 0].max
+
+        MemoryStats.new(
+          total_bytes: total_bytes,
+          free_bytes: free_bytes,
+          available_bytes: available_bytes,
+          used_bytes: used_bytes,
+          details: {
+            buffers_bytes: buffers_bytes,
+            cached_bytes: cached_bytes,
+            swap_total_bytes: (meminfo["SwapTotal"] || 0) * 1024,
+            swap_free_bytes: (meminfo["SwapFree"] || 0) * 1024
+          }
+        )
+      end
+
+      # Collect System statistics on Linux
+      def system
+        os_name, os_ver = parse_os_release
+        arch = execute("uname -m")
+        arch = "unknown" if arch.empty?
+
+        kernel = execute("uname -r")
+        kernel = "unknown" if kernel.empty?
+
+        uptime_secs = parse_uptime
+
+        SystemStats.new(
+          os: os_name,
+          os_family: :linux,
+          os_version: os_ver,
+          hostname: hostname,
+          architecture: arch,
+          kernel: kernel,
+          uptime_seconds: uptime_secs
+        )
+      end
+
+      # Internal helper: parse /proc/meminfo
+      def parse_meminfo
+        return {} unless File.exist?(@proc_meminfo_path)
+
+        info = {}
+        File.foreach(@proc_meminfo_path) do |line|
+          if (m = line.match(/^(\w+):\s+(\d+)\s+kB/))
+            info[m[1]] = m[2].to_i
+          end
+        end
+        info
+      rescue StandardError
+        {}
+      end
+
+      # Internal helper: parse /proc/loadavg
+      def parse_load_average
+        return { one_minute: 0.0, five_minutes: 0.0, fifteen_minutes: 0.0 } unless File.exist?(@proc_loadavg_path)
+
+        parts = File.read(@proc_loadavg_path).strip.split(/\s+/)
+        {
+          one_minute: parts[0].to_f,
+          five_minutes: parts[1].to_f,
+          fifteen_minutes: parts[2].to_f
+        }
+      rescue StandardError
+        { one_minute: 0.0, five_minutes: 0.0, fifteen_minutes: 0.0 }
+      end
+
+      # Internal helper: parse /proc/uptime
+      def parse_uptime
+        return 0 unless File.exist?(@proc_uptime_path)
+
+        parts = File.read(@proc_uptime_path).strip.split(/\s+/)
+        parts[0].to_f.to_i
+      rescue StandardError
+        0
+      end
+
+      # Internal helper: parse /proc/cpuinfo
+      def parse_cpuinfo
+        return [nil, nil] unless File.exist?(@proc_cpuinfo_path)
+
+        model = nil
+        physical_core_pairs = {}
+        current_phys_id = nil
+
+        File.foreach(@proc_cpuinfo_path) do |line|
+          line = line.strip
+          if line.start_with?("model name")
+            model ||= line.split(":", 2)[1]&.strip
+          elsif line.start_with?("physical id")
+            current_phys_id = line.split(":", 2)[1]&.strip
+          elsif line.start_with?("core id") && current_phys_id
+            core_id = line.split(":", 2)[1]&.strip
+            physical_core_pairs["#{current_phys_id}-#{core_id}"] = true
+          end
+        end
+
+        phys_count = physical_core_pairs.empty? ? nil : physical_core_pairs.size
+        [model, phys_count]
+      rescue StandardError
+        [nil, nil]
+      end
+
+      # Internal helper: read first CPU line from /proc/stat
+      def read_cpu_ticks
+        return nil unless File.exist?(@proc_stat_path)
+
+        File.foreach(@proc_stat_path) do |line|
+          if line.start_with?("cpu ")
+            # cpu  user nice system idle iowait irq softirq steal guest guest_nice
+            fields = line.strip.split(/\s+/)[1..-1].map(&:to_i)
+            idle = (fields[3] || 0) + (fields[4] || 0) # idle + iowait
+            total = fields.inject(0, :+)
+            return { idle: idle, total: total }
+          end
+        end
+        nil
+      rescue StandardError
+        nil
+      end
+
+      # Internal helper: calculate CPU % using sample interval
+      def calculate_cpu_usage(interval)
+        sample1 = read_cpu_ticks
+        return 0.0 unless sample1
+
+        if interval > 0.0
+          sleep(interval)
+          sample2 = read_cpu_ticks
+          return 0.0 unless sample2
+
+          delta_total = sample2[:total] - sample1[:total]
+          delta_idle  = sample2[:idle] - sample1[:idle]
+
+          if delta_total.positive?
+            usage = ((delta_total - delta_idle).to_f / delta_total) * 100.0
+            return [[usage, 0.0].max, 100.0].min
+          end
+        end
+
+        0.0
+      end
+
+      # Internal helper: parse /etc/os-release
+      def parse_os_release
+        return ["Linux", "unknown"] unless File.exist?(@os_release_path)
+
+        env = {}
+        File.foreach(@os_release_path) do |line|
+          line = line.strip
+          next if line.empty? || line.start_with?("#")
+
+          if (m = line.match(/^([A-Za-z_]+)=(?:"([^"]*)"|'([^']*)'|(.*))$/))
+            key = m[1]
+            val = m[2] || m[3] || m[4]
+            env[key] = val
+          end
+        end
+
+        name = env["PRETTY_NAME"] || env["NAME"] || "Linux"
+        version = env["VERSION_ID"] || env["VERSION"] || "unknown"
+        [name, version]
+      rescue StandardError
+        ["Linux", "unknown"]
+      end
+    end
+  end
+end