process-metrics 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b288419449c98ce2b53cc2ecb8d3d2660a473c17677b66e6f18015b803db1482
-  data.tar.gz: 67b4d639f7744814e47e61aac54ef7c588557a94ca8454926594d742f9cf88ce
+  metadata.gz: bb30f9e1ffed610ad4a6735a8875f6438eae603ce53e6cb67274e7f893f1c4d5
+  data.tar.gz: 0474ced532e19377ee8b4b7003c21d1a098afc8df5fb3f9865ea163aa756eced
 SHA512:
-  metadata.gz: 0a1686b0609d8009a2d5a26b659876c29c5378d89b35b39777b5d55d53413b2a10558470075ce0303959f77213ceef101cad19547dc95743440d0243af2746e1
-  data.tar.gz: 13a3e9bbc06eb5412a6b37c499f531eebf58317c1944d0e679dd68d8b87abc4450e62b7166c435334745555d26bb873b9ddc47d65324bdf17832b27865f60a2c
+  metadata.gz: 898911e287967bb88596747da31bc6e956bdf4aa8bdea23b461df7998922155d72bd577ca0092320514aa41738547576abd379779a89cf66a22d5a63f0e279f8
+  data.tar.gz: 0f78a3b25a090f9823feae392358281e10f1828a0cb4d324ad880a0a877e0ae34d8cd9d4fbedf7018fe847b5dff1b2f2c6a27702eebb61d714afb46faf4eda7a

data/context/getting-started.md

@@ -32,29 +32,30 @@ Process::Metrics::General.capture(pid: Process.pid)
 # => 
 # {3517456=>
 #   #<struct Process::Metrics::General
-#    pid=3517456,
-#    ppid=3517432,
-#    pgid=3517456,
+#    process_id=3517456,
+#    parent_process_id=3517432,
+#    process_group_id=3517456,
 #    processor_utilization=0.0,
-#    vsz=0,
-#    rss=486892,
-#    time=29928,
-#    etime=2593,
+#    virtual_size=445768278528,
+#    resident_size=20348928,
+#    processor_time=0.05,
+#    elapsed_time=2.0,
 #    command="irb",
 #    memory=
 #     #<struct Process::Metrics::Memory
 #      map_count=193,
-#      total_size=486896,
-#      resident_size=30556,
-#      proportional_size=25672,
-#      shared_clean_size=5008,
+#      resident_size=31289344,
+#      proportional_size=26288128,
+#      shared_clean_size=5128192,
 #      shared_dirty_size=0,
-#      private_clean_size=5180,
-#      private_dirty_size=20368,
-#      referenced_size=30548,
-#      anonymous_size=20376,
+#      private_clean_size=5304320,
+#      private_dirty_size=20856832,
+#      referenced_size=31281152,
+#      anonymous_size=20865024,
 #      swap_size=0,
-#      proportional_swap_size=0>>}
+#      proportional_swap_size=0,
+#      minor_faults=0,
+#      major_faults=0>>}
 ```
 
 If you want to capture a tree of processes, you can specify the `ppid:` option instead.
@@ -67,8 +68,8 @@ The {ruby Process::Metrics::General} struct contains the following fields:
 - `parent_process_id` - Parent Process ID, the process ID of the process that started this process.
 - `process_group_id` - Process Group ID, the process group ID of the process, which can be shared by multiple processes.
 - `processor_utilization` - Processor Utilization (%), the percentage of CPU time used by the process (over a system-specific duration).
-- `total_size` - Memory Size (KB), the total size of the process's memory space (usually over-estimated as it doesn't take into account shared memory).
-- `resident_size` - Resident (Set) Size (KB), the amount of physical memory used by the process.
+- `total_size` - Memory Size (bytes), the total size of the process's memory space (usually over-estimated as it doesn't take into account shared memory).
+- `resident_size` - Resident (Set) Size (bytes), the amount of physical memory used by the process.
 - `processor_time` - CPU Time (s), the amount of CPU time used by the process.
 - `elapsed_time` - Elapsed Time (s), the amount of time the process has been running.
 - `command` - Command Name, the name of the command that started the process.
@@ -76,15 +77,15 @@ The {ruby Process::Metrics::General} struct contains the following fields:
 The {ruby Process::Metrics::Memory} struct contains the following fields:
 
 - `map_count` - Number of Memory Mappings, e.g. number of thread stacks, fiber stacks, shared libraries, memory mapped files, etc.
-- `resident_size` - Resident Memory Size (KB), the amount of physical memory used by the process.
-- `proportional_size` - Proportional Memory Size (KB), the amount of memory that the process is using, taking into account shared memory.
-- `shared_clean_size` - Shared Clean Memory Size (KB), the amount of shared memory that is clean (not modified).
-- `shared_dirty_size` - Shared Dirty Memory Size (KB), the amount of shared memory that is dirty (modified).
-- `private_clean_size` - Private Clean Memory Size (KB), the amount of private memory that is clean (not modified).
-- `private_dirty_size` - Private Dirty Memory Size (KB), the amount of private memory that is dirty (modified).
-- `referenced_size` - Referenced Memory Size (KB), active page-cache that isn't going to be reclaimed any time soon.
-- `anonymous_size` - Anonymous Memory Size (KB), mapped memory that isn't backed by a file.
-- `swap_size` - Swap Memory Size (KB), the amount of memory that has been swapped to disk.
-- `proportional_swap_size` - Proportional Swap Memory Size (KB), the amount of memory that has been swapped to disk, excluding shared memory.
+- `resident_size` - Resident Memory Size (bytes), the amount of physical memory used by the process.
+- `proportional_size` - Proportional Memory Size (bytes), the amount of memory that the process is using, taking into account shared memory.
+- `shared_clean_size` - Shared Clean Memory Size (bytes), the amount of shared memory that is clean (not modified).
+- `shared_dirty_size` - Shared Dirty Memory Size (bytes), the amount of shared memory that is dirty (modified).
+- `private_clean_size` - Private Clean Memory Size (bytes), the amount of private memory that is clean (not modified).
+- `private_dirty_size` - Private Dirty Memory Size (bytes), the amount of private memory that is dirty (modified).
+- `referenced_size` - Referenced Memory Size (bytes), active page-cache that isn't going to be reclaimed any time soon.
+- `anonymous_size` - Anonymous Memory Size (bytes), mapped memory that isn't backed by a file.
+- `swap_size` - Swap Memory Size (bytes), the amount of memory that has been swapped to disk.
+- `proportional_swap_size` - Proportional Swap Memory Size (bytes), the amount of memory that has been swapped to disk, excluding shared memory.
 
 In general, the interpretation of these fields is operating system specific. At best, they provide a rough estimate of the process's memory usage, but you should consult the documentation for your operating system for more details on exactly what each field represents.

data/lib/process/metrics/command/summary.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2020-2025, by Samuel Williams.
+# Copyright, 2020-2026, by Samuel Williams.
 
 require "samovar"
 
@@ -90,23 +90,28 @@ module Process
 				UNITS = ["KiB", "MiB", "GiB"]
 				
 				# Format a memory size value in human-readable units.
-				# @parameter value [Numeric] The size value in kilobytes.
+				# @parameter value [Numeric] The size value in bytes.
 				# @parameter units [Array(String)] The unit labels to use for scaling.
 				# @returns [String] A formatted string with value and unit (e.g., "512KiB", "1.5MiB").
 				def format_size(value, units: UNITS)
-					unit = 0
+					unit = -1
 					
-					while value > 1024.0 && unit < units.size
+					while value >= 1024.0 && unit < units.size - 1
 						value /= 1024.0
 						unit += 1
 					end
 					
-					return "#{value.round(unit)}#{units[unit]}"
+					if unit < 0
+						# Value is less than 1 KiB, show in bytes
+						return "#{value.round(0)}B"
+					else
+						return "#{value.round(unit)}#{units[unit]}"
+					end
 				end
 				
 				# Format a memory value with a horizontal bar showing utilization relative to total.
-				# @parameter value [Numeric] The memory value in kilobytes.
-				# @parameter total [Numeric] The total memory available in kilobytes.
+				# @parameter value [Numeric] The memory value in bytes.
+				# @parameter total [Numeric] The total memory available in bytes.
 				# @parameter terminal [Console::Terminal] The terminal to output styled text.
 				def format_memory(value, total, terminal)
 					if value > (total * 0.8)
@@ -123,10 +128,11 @@ module Process
 				end
 				
 				# Get the total memory to use for percentage calculations.
-				# @returns [Integer] Total memory in kilobytes.
+				# @returns [Integer] Total memory in bytes.
 				def total_memory
 					if total_memory = @options[:total_memory]
-						return total_memory * 1024
+						# Convert from MiB to bytes
+						return total_memory * 1024 * 1024
 					else
 						return Process::Metrics::Memory.total_size
 					end

data/lib/process/metrics/general/linux.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2019-2026, by Samuel Williams.
+
+require "etc"
+
+module Process
+	module Metrics
+		# General process information by reading /proc. Used on Linux to avoid spawning `ps`.
+		# We read directly from the kernel (proc(5)) so there is no subprocess and no parsing of
+		# external command output; same data source as the kernel uses for process accounting.
+		# Parses /proc/[pid]/stat and /proc/[pid]/cmdline for each process.
+		module General::Linux
+			# Clock ticks per second for /proc stat times (utime, stime, starttime).
+			CLK_TCK = Etc.sysconf(Etc::SC_CLK_TCK) rescue 100
+			
+			# Page size in bytes for RSS (resident set size is in pages in /proc/pid/stat).
+			PAGE_SIZE = Etc.sysconf(Etc::SC_PAGESIZE) rescue 4096
+			
+			# Whether /proc is available so we can list processes without ps.
+			def self.supported?
+				File.directory?("/proc") && File.readable?("/proc/self/stat")
+			end
+			
+			# Capture process information from /proc. If given `pid`, captures only those process(es). If given `ppid`, captures that parent and all descendants. Both can be given to capture a process and its children.
+			# @parameter pid [Integer | Array(Integer)] Process ID(s) to capture.
+			# @parameter ppid [Integer | Array(Integer)] Parent process ID(s) to include children for.
+			# @parameter memory [Boolean] Whether to capture detailed memory metrics (default: Memory.supported?).
+			# @returns [Hash<Integer, General>] Map of PID to General instance.
+			def self.capture(pid: nil, ppid: nil, memory: Memory.supported?)
+				# When filtering by ppid we need the full process list to build the parent-child tree,
+				# so we enumerate all numeric /proc entries; when only pid is set we read just those.
+				pids_to_read = if pid && ppid.nil?
+					Array(pid)
+				else
+					Dir.children("/proc").filter{|e| e.match?(/\A\d+\z/)}.map(&:to_i)
+				end
+				
+				uptime_jiffies = nil
+				
+				processes = {}
+				pids_to_read.each do |pid|
+					stat_path = "/proc/#{pid}/stat"
+					next unless File.readable?(stat_path)
+					
+					stat_content = File.read(stat_path)
+					# comm field can contain spaces and parentheses; find the closing ')' (proc(5)).
+					closing_paren_index = stat_content.rindex(")")
+					next unless closing_paren_index
+					
+					executable_name = stat_content[1...closing_paren_index]
+					fields = stat_content[(closing_paren_index + 2)..].split(/\s+/)
+					# After comm: state(3), ppid(4), pgrp(5), ... utime(14), stime(15), ... starttime(22), vsz(23), rss(24). 0-based: ppid=1, pgrp=2, utime=11, stime=12, starttime=19, vsz=20, rss=21.
+					parent_process_id = fields[1].to_i
+					process_group_id = fields[2].to_i
+					utime = fields[11].to_i
+					stime = fields[12].to_i
+					starttime = fields[19].to_i
+					virtual_size = fields[20].to_i
+					resident_pages = fields[21].to_i
+					
+					# Read /proc/uptime once per capture and reuse for every process (starttime is in jiffies since boot).
+					uptime_jiffies ||= begin
+						uptime_seconds = File.read("/proc/uptime").split(/\s+/).first.to_f
+						(uptime_seconds * CLK_TCK).to_i
+					end
+					
+					processor_time = (utime + stime).to_f / CLK_TCK
+					elapsed_time = [(uptime_jiffies - starttime).to_f / CLK_TCK, 0.0].max
+					
+					command = read_command(pid, executable_name)
+					
+					processes[pid] = General.new(
+						pid,
+						parent_process_id,
+						process_group_id,
+						0.0, # processor_utilization: would need two samples; not available from single stat read
+						virtual_size,
+						resident_pages * PAGE_SIZE,
+						processor_time,
+						elapsed_time,
+						command,
+						nil
+					)
+				rescue Errno::ENOENT, Errno::ESRCH, Errno::EACCES
+					# Process disappeared or we can't read it.
+					next
+				end
+				
+				# Restrict to the requested pid/ppid subtree using the same tree logic as the ps backend.
+				if ppid
+					pids = Set.new
+					hierarchy = General.build_tree(processes)
+					General.expand_children(Array(pid), hierarchy, pids) if pid
+					General.expand_children(Array(ppid), hierarchy, pids)
+					processes.select!{|process_id, _| pids.include?(process_id)}
+				end
+				
+				General.capture_memory(processes) if memory
+				
+				processes
+			end
+			
+			# Read command line from /proc/[pid]/cmdline; fall back to executable name from stat if empty.
+			# Use binread because cmdline is NUL-separated and may contain non-UTF-8 bytes; we split on NUL and join for display.
+			def self.read_command(pid, command_fallback)
+				path = "/proc/#{pid}/cmdline"
+				return command_fallback unless File.readable?(path)
+				
+				cmdline_content = File.binread(path)
+				return command_fallback if cmdline_content.empty?
+				
+				# cmdline is NUL-separated; replace with spaces for display.
+				cmdline_content.split("\0").join(" ").strip
+			rescue Errno::ENOENT, Errno::ESRCH, Errno::EACCES
+				command_fallback
+			end
+		end
+	end
+end
+
+if Process::Metrics::General::Linux.supported?
+	class << Process::Metrics::General
+		def capture(...)
+			Process::Metrics::General::Linux.capture(...)
+		end
+	end
+else
+	require_relative "process_status"
+end

data/lib/process/metrics/general/process_status.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2019-2026, by Samuel Williams.
+
+module Process
+	module Metrics
+		# General process information via the process status command (`ps`). Used on non-Linux platforms (e.g. Darwin)
+		# where there is no /proc; ps is the portable way to get pid, ppid, times, and memory in one pass.
+		module General::ProcessStatus
+			PS = "ps"
+			
+			# The fields that will be extracted from the `ps` command (order matches -o output).
+			FIELDS = {
+				pid: ->(value){value.to_i},
+				ppid: ->(value){value.to_i},
+				pgid: ->(value){value.to_i},
+				pcpu: ->(value){value.to_f},
+				vsz: ->(value){value.to_i * 1024},
+				rss: ->(value){value.to_i * 1024},
+				time: Process::Metrics.method(:duration),
+				etime: Process::Metrics.method(:duration),
+				command: ->(value){value},
+			}
+			
+			# Whether process listing via ps is available on this system.
+			def self.supported?
+				system("which", PS, out: File::NULL, err: File::NULL)
+			end
+			
+			# Capture process information using ps. If given a `pid`, captures that process; if given `ppid`, captures that process and all descendants. Specify both to capture a process and its children.
+			# @parameter pid [Integer | Array(Integer)] Process ID(s) to capture.
+			# @parameter ppid [Integer | Array(Integer)] Parent process ID(s) to include children for.
+			# @parameter memory [Boolean] Whether to capture detailed memory metrics (default: Memory.supported?).
+			# @returns [Hash<Integer, General>] Map of PID to General instance.
+			def self.capture(pid: nil, ppid: nil, memory: Memory.supported?)
+				spawned_pid = nil
+				
+				header, *lines = IO.pipe do |input, output|
+					arguments = [PS]
+					
+					# When filtering by ppid we need the full process list to build the tree, so use "ax"; otherwise limit to -p.
+					if pid && ppid.nil?
+						arguments.push("-p", Array(pid).join(","))
+					else
+						arguments.push("ax")
+					end
+					
+					arguments.push("-o", FIELDS.keys.join(","))
+					
+					spawned_pid = Process.spawn(*arguments, out: output)
+					output.close
+					
+					input.readlines.map(&:strip)
+				ensure
+					input.close
+					
+					# Always kill and reap the ps subprocess so we never leave it hanging if the pipe closes early.
+					if spawned_pid
+						begin
+							Process.kill(:KILL, spawned_pid)
+							Process.wait(spawned_pid)
+						rescue => error
+							warn "Failed to cleanup ps process #{spawned_pid}:\n#{error.full_message}"
+						end
+					end
+				end
+				
+				processes = {}
+				
+				lines.each do |line|
+					next if line.empty?
+					
+					values = line.split(/\s+/, FIELDS.size)
+					next if values.size < FIELDS.size
+					
+					record = FIELDS.keys.map.with_index{|key, i| FIELDS[key].call(values[i])}
+					instance = General.new(*record, nil)
+					processes[instance.process_id] = instance
+				end
+				
+				# Restrict to the requested pid/ppid subtree; exclude our own ps process from the result.
+				if ppid
+					pids = Set.new
+					hierarchy = General.build_tree(processes)
+					General.expand_children(Array(pid), hierarchy, pids) if pid
+					General.expand_children(Array(ppid), hierarchy, pids)
+					processes.select!{|process_id, _| process_id != spawned_pid && pids.include?(process_id)}
+				else
+					processes.delete(spawned_pid) if spawned_pid
+				end
+				
+				General.capture_memory(processes) if memory
+				
+				processes
+			end
+		end
+	end
+end
+
+# Wire General.capture to this implementation when ProcessStatus is available and the Linux backend is not active (so Linux can load both for comparison tests).
+linux_supported = defined?(Process::Metrics::General::Linux) && Process::Metrics::General::Linux.supported?
+if Process::Metrics::General::ProcessStatus.supported? && !linux_supported
+	class << Process::Metrics::General
+		def capture(...)
+			Process::Metrics::General::ProcessStatus.capture(...)
+		end
+	end
+end

data/lib/process/metrics/general.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2019-2025, by Samuel Williams.
+# Copyright, 2019-2026, by Samuel Williams.
 
 require_relative "memory"
 require "set"
@@ -9,8 +9,6 @@ require "json"
 
 module Process
 	module Metrics
-		PS = "ps"
-		
 		DURATION = /\A
 			(?:(?<days>\d+)-)?              # Optional days (e.g., '2-')
 			(?:(?<hours>\d+):)?             # Optional hours (e.g., '1:')
@@ -36,19 +34,6 @@ module Process
 			end
 		end
 		
-		# The fields that will be extracted from the `ps` command.
-		FIELDS = {
-			pid: ->(value){value.to_i}, # Process ID
-			ppid: ->(value){value.to_i}, # Parent Process ID
-			pgid: ->(value){value.to_i}, # Process Group ID
-			pcpu: ->(value){value.to_f}, # Percentage CPU
-			vsz: ->(value){value.to_i}, # Virtual Size (KiB)
-			rss: ->(value){value.to_i}, # Resident Size (KiB)
-			time: self.method(:duration), # CPU Time (seconds)
-			etime: self.method(:duration), # Elapsed Time (seconds)
-			command: ->(value){value}, # Command (name of the process)
-		}
-		
 		# General process information.
 		class General < Struct.new(:process_id, :parent_process_id, :process_group_id, :processor_utilization, :virtual_size, :resident_size, :processor_time, :elapsed_time, :command, :memory)
 			# Convert the object to a JSON serializable hash.
@@ -73,7 +58,7 @@ module Process
 				as_json.to_json(*arguments)
 			end
 			
-			# The total size of the process in memory, in kilobytes.
+			# The total size of the process in memory, in bytes.
 			def total_size
 				if memory = self.memory
 					memory.proportional_size
@@ -132,77 +117,13 @@ module Process
 					process.memory = Memory.capture(pid, count: count)
 				end
 			end
-			
-			# Capture process information. If given a `pid`, it will capture the details of that process. If given a `ppid`, it will capture the details of all child processes. Specify both `pid` and `ppid` if you want to capture a process and all its children.
-			#
-			# @parameter pid [Integer] The process ID to capture.
-			# @parameter ppid [Integer] The parent process ID to capture.
-			def self.capture(pid: nil, ppid: nil, memory: Memory.supported?)
-				ps_pid = nil
-				
-				# Extract the information from the `ps` command:
-				header, *lines = IO.pipe do |input, output|
-					arguments = [PS]
-					
-					if pid && ppid.nil?
-						arguments.push("-p", Array(pid).join(","))
-					else
-						arguments.push("ax")
-					end
-					
-					arguments.push("-o", FIELDS.keys.join(","))
-					
-					ps_pid = Process.spawn(*arguments, out: output)
-					output.close
-					
-					input.readlines.map(&:strip)
-				ensure
-					input.close
-					
-					if ps_pid
-						begin
-							# Make sure to kill the ps process if it's still running:
-							Process.kill(:KILL, ps_pid)
-							# Reap the process:
-							Process.wait(ps_pid)
-						rescue => error
-							warn "Failed to cleanup ps process #{ps_pid}:\n#{error.full_message}"
-						end
-					end
-				end
-				
-				processes = {}
-				
-				lines.map do |line|
-					record = FIELDS.
-						zip(line.split(/\s+/, FIELDS.size)).
-						map{|(key, type), value| type.call(value)}
-					instance = self.new(*record)
-					
-					processes[instance.process_id] = instance
-				end
-				
-				if ppid
-					pids = Set.new
-					
-					hierarchy = self.build_tree(processes)
-					
-					self.expand_children(Array(pid), hierarchy, pids)
-					self.expand_children(Array(ppid), hierarchy, pids)
-					
-					processes.select! do |pid, process|
-						if pid != ps_pid
-							pids.include?(pid)
-						end
-					end
-				end
-				
-				if memory
-					self.capture_memory(processes)
-				end
-				
-				return processes
-			end
 		end
 	end
 end
+
+# One backend provides General.capture: Linux uses /proc (no subprocess); other platforms use ps.
+if RUBY_PLATFORM.include?("linux")
+	require_relative "general/linux"
+else
+	require_relative "general/process_status"
+end

data/lib/process/metrics/host/memory/darwin.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025-2026, by Samuel Williams.
+
+module Process
+	module Metrics
+		module Host
+			# Darwin (macOS) implementation of host memory metrics.
+			# Uses sysctl (hw.memsize), vm_stat (free + inactive pages), and vm.swapusage for swap.
+			class Memory::Darwin
+				# Parse a size string from vm.swapusage (e.g. "1024.00M", "512.00K") into bytes.
+				# @parameter size_string [String | Nil] The size string from sysctl vm.swapusage.
+				# @returns [Integer | Nil] Size in bytes, or nil if size_string is nil/empty.
+				def self.parse_swap_size(size_string)
+					return nil unless size_string
+					
+					size_string = size_string.strip
+					
+					case size_string
+					when /([\d.]+)M/i then ($1.to_f * 1024 * 1024).round
+					when /([\d.]+)G/i then ($1.to_f * 1024 * 1024 * 1024).round
+					when /([\d.]+)K/i then ($1.to_f * 1024).round
+					else size_string.to_f.round
+					end
+				end
+				
+				# Capture current host memory. Reads total (hw.memsize), free (vm_stat), and swap (vm.swapusage).
+				# @returns [Host::Memory | Nil] A Host::Memory instance, or nil if capture fails.
+				def self.capture
+					total = capture_total
+					return nil unless total && total.positive?
+					
+					free = capture_free
+					return nil unless free
+					
+					free = 0 if free.negative?
+					used = [total - free, 0].max
+					swap_total, swap_used = capture_swap
+					
+					return Host::Memory.new(total, used, free, swap_total, swap_used)
+				end
+				
+				# Total physical RAM in bytes, from sysctl hw.memsize.
+				# @returns [Integer | Nil]
+				def self.capture_total
+					IO.popen(["sysctl", "-n", "hw.memsize"], "r", &:read)&.strip&.to_i
+				end
+				
+				# Free + inactive (reclaimable) memory in bytes, from vm_stat. Matches Linux MemAvailable semantics.
+				# @returns [Integer | Nil]
+				def self.capture_free
+					output = IO.popen(["vm_stat"], "r", &:read)
+					page_size = output[/page size of (\d+) bytes/, 1]&.to_i
+					return nil unless page_size && page_size.positive?
+					
+					pages_free = output[/Pages free:\s*(\d+)/, 1]&.to_i || 0
+					pages_inactive = output[/Pages inactive:\s*(\d+)/, 1]&.to_i || 0
+					return (pages_free + pages_inactive) * page_size
+				end
+				
+				# Swap total and used in bytes, from sysctl vm.swapusage (e.g. "total = 64.00M  used = 32.00M  free = 32.00M").
+				# @returns [Array(Integer | Nil, Integer | Nil)] [swap_total_bytes, swap_used_bytes], or [nil, nil] if unavailable.
+				def self.capture_swap
+					output = IO.popen(["sysctl", "-n", "vm.swapusage"], "r", &:read)
+					return [nil, nil] unless output
+					
+					total_string = output[/total\s*=\s*([\d.]+\s*[KMG]?)/i, 1]
+					used_string = output[/used\s*=\s*([\d.]+\s*[KMG]?)/i, 1]
+					swap_total = total_string ? parse_swap_size(total_string) : nil
+					swap_used = used_string ? parse_swap_size(used_string) : nil
+					
+					return swap_total, swap_used
+				end
+			end
+		end
+	end
+end
+
+# Wire Host::Memory to this implementation on Darwin.
+class << Process::Metrics::Host::Memory
+	def capture
+		Process::Metrics::Host::Memory::Darwin.capture
+	end
+	
+	def supported?
+		File.exist?("/usr/bin/vm_stat")
+	end
+end

data/lib/process/metrics/host/memory/linux.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025-2026, by Samuel Williams.
+
+module Process
+	module Metrics
+		module Host
+			# Linux implementation of host memory metrics.
+			# Uses cgroups v2 (memory.max, memory.current) or cgroups v1 (memory.limit_in_bytes, memory.usage_in_bytes) when in a container;
+			# otherwise reads /proc/meminfo (MemTotal, MemAvailable/MemFree, SwapTotal/SwapFree). Parses meminfo once per capture and reuses it.
+			class Memory::Linux
+				# Threshold for distinguishing actual memory limits from "unlimited" sentinel values in cgroups v1.
+				# In cgroups v1, when memory.limit_in_bytes is set to unlimited (by writing -1), the kernel stores a very large sentinel near 2^63.
+				# Any value >= 2^60 (1 exabyte) is treated as unlimited and we fall back to /proc/meminfo.
+				# Reference: https://www.kernel.org/doc/Documentation/cgroup-v1/memory.txt
+				CGROUP_V1_UNLIMITED_THRESHOLD = 2**60
+				
+				def initialize
+					@meminfo = false
+				end
+				
+				# Capture current host memory. Reads total and used (from cgroup or meminfo), computes free, and parses swap from meminfo.
+				# @returns [Host::Memory | Nil]
+				def capture
+					total = capture_total
+					return nil unless total && total.positive?
+					
+					used = capture_used(total)
+					used = 0 if used.nil? || used.negative?
+					used = [used, total].min
+					free = total - used
+					
+					swap_total, swap_used = capture_swap
+					
+					return Host::Memory.new(total, used, free, swap_total, swap_used)
+				end
+				
+				private
+				
+				# Memoized /proc/meminfo contents. Used for total (MemTotal), used (via MemAvailable), and swap when not in a cgroup.
+				# @returns [String | Nil]
+				def meminfo
+					if @meminfo == false
+						@meminfo = File.read("/proc/meminfo") rescue nil
+					end
+					
+					return @meminfo
+				end
+				
+				# Total memory in bytes: cgroups v2 memory.max, cgroups v1 memory.limit_in_bytes (if < threshold), else MemTotal from meminfo.
+				# @returns [Integer | Nil]
+				def capture_total
+					if File.exist?("/sys/fs/cgroup/memory.max")
+						limit = File.read("/sys/fs/cgroup/memory.max").strip
+						return limit.to_i if limit != "max"
+					end
+					
+					if File.exist?("/sys/fs/cgroup/memory/memory.limit_in_bytes")
+						limit = File.read("/sys/fs/cgroup/memory/memory.limit_in_bytes").strip.to_i
+						return limit if limit > 0 && limit < CGROUP_V1_UNLIMITED_THRESHOLD
+					end
+					
+					unless meminfo_content = self.meminfo
+						return nil
+					end
+					
+					meminfo_content.each_line do |line|
+						if /MemTotal:\s*(?<total>\d+)\s*kB/ =~ line
+							return $~[:total].to_i * 1024
+						end
+					end
+					
+					return nil
+				end
+				
+				# Current memory usage in bytes: cgroups v2 memory.current, cgroups v1 memory.usage_in_bytes, or total - MemAvailable from meminfo.
+				# @parameter total [Integer] Total memory (used to compute used from MemAvailable when not in cgroup).
+				# @returns [Integer | Nil]
+				def capture_used(total)
+					if File.exist?("/sys/fs/cgroup/memory.current")
+						current = File.read("/sys/fs/cgroup/memory.current").strip.to_i
+						return current
+					end
+					
+					if File.exist?("/sys/fs/cgroup/memory/memory.usage_in_bytes")
+						limit = File.read("/sys/fs/cgroup/memory/memory.limit_in_bytes").strip.to_i
+						if limit > 0 && limit < CGROUP_V1_UNLIMITED_THRESHOLD
+							return File.read("/sys/fs/cgroup/memory/memory.usage_in_bytes").strip.to_i
+						end
+					end
+					
+					unless meminfo_content = self.meminfo
+						return nil
+					end
+					
+					available_kilobytes = meminfo_content[/MemAvailable:\s*(\d+)\s*kB/, 1]&.to_i
+					available_kilobytes ||= meminfo_content[/MemFree:\s*(\d+)\s*kB/, 1]&.to_i
+					return nil unless available_kilobytes
+					
+					return [total - (available_kilobytes * 1024), 0].max
+				end
+				
+				# Swap total and used in bytes from meminfo (SwapTotal, SwapFree).
+				# @returns [Array(Integer, Integer)] [swap_total_bytes, swap_used_bytes], or [nil, nil] if no swap.
+				def capture_swap
+					return [nil, nil] unless meminfo_content = self.meminfo
+					swap_total_kilobytes = meminfo_content[/SwapTotal:\s*(\d+)\s*kB/, 1]&.to_i
+					swap_free_kilobytes = meminfo_content[/SwapFree:\s*(\d+)\s*kB/, 1]&.to_i
+					
+					return [nil, nil] unless swap_total_kilobytes
+					
+					swap_total_bytes = swap_total_kilobytes * 1024
+					swap_used_bytes = (swap_total_kilobytes - (swap_free_kilobytes || 0)) * 1024
+					
+					return swap_total_bytes, swap_used_bytes
+				end
+			end
+		end
+	end
+end
+
+# Wire Host::Memory to this implementation on Linux.
+class << Process::Metrics::Host::Memory
+	def capture
+		Process::Metrics::Host::Memory::Linux.new.capture
+	end
+	
+	def supported?
+		File.exist?("/proc/meminfo")
+	end
+end

data/lib/process/metrics/host/memory.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025-2026, by Samuel Williams.
+
+module Process
+	module Metrics
+		# Per-host (system-wide) memory metrics. Use Host::Memory for total/used/free and swap; use Process::Metrics::Memory for per-process metrics.
+		module Host
+			# Struct for host memory snapshot. All sizes in bytes.
+			# @attribute total [Integer] Total memory (cgroup limit when in a container, else physical RAM).
+			# @attribute used [Integer] Memory in use (total - free).
+			# @attribute free [Integer] Available memory (MemAvailable-style: free + reclaimable).
+			# @attribute swap_total [Integer, nil] Total swap, or nil if not available.
+			# @attribute swap_used [Integer, nil] Swap in use, or nil if not available.
+			Memory = Struct.new(:total, :used, :free, :swap_total, :swap_used) do
+				alias as_json to_h
+				
+				def to_json(*arguments)
+					as_json.to_json(*arguments)
+				end
+				
+				# Create a zero-initialized Host::Memory instance.
+				# @returns [Memory]
+				def self.zero
+					self.new(0, 0, 0, nil, nil)
+				end
+				
+				# Whether host memory capture is supported on this platform.
+				# @returns [Boolean]
+				def self.supported?
+					false
+				end
+				
+				# Capture current host memory. Implemented by Host::Memory::Linux or Host::Memory::Darwin (in host/memory/linux.rb, host/memory/darwin.rb).
+				# @returns [Memory | Nil] A Host::Memory instance, or nil if not supported or capture failed.
+				def self.capture
+					return nil
+				end
+			end
+		end
+	end
+end
+
+if RUBY_PLATFORM.include?("linux")
+	require_relative "memory/linux"
+elsif RUBY_PLATFORM.include?("darwin")
+	require_relative "memory/darwin"
+end

data/lib/process/metrics/memory/darwin.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2025, by Samuel Williams.
+# Copyright, 2025-2026, by Samuel Williams.
 
 module Process
 	module Metrics
-		# Darwin (macOS) implementation of memory metrics using vmmap.
+		# Darwin (macOS) implementation of per-process memory metrics using vmmap(1).
+		# Parses vmmap output for virtual/resident/dirty/swap per region and maps sharing mode (PRV, COW, SHM) to private/shared fields.
 		class Memory::Darwin
 			VMMAP = "/usr/bin/vmmap"
 			
@@ -14,32 +15,21 @@ module Process
 				File.executable?(VMMAP)
 			end
 			
-			# @returns [Numeric] Total memory size in kilobytes.
-			def self.total_size
-				# sysctl hw.memsize
-				IO.popen(["sysctl", "hw.memsize"], "r") do |io|
-					io.each_line do |line|
-						if line =~ /hw.memsize: (\d+)/
-							return $1.to_i / 1024
-						end
-					end
-				end
-			end
-			
-			# Parse a size string from vmmap output into kilobytes.
-			# @parameter string [String | Nil] The size string (e.g., "4K", "1.5M", "2G").
-			# @returns [Integer] The size in kilobytes.
-			def self.parse_size(string)
-				return 0 unless string
+			# Parse a size string from vmmap (e.g. "4K", "1.5M", "2G") into bytes.
+			# @parameter size_string [String | Nil]
+			# @returns [Integer]
+			def self.parse_size(size_string)
+				return 0 unless size_string
 				
-				case string.strip
-				when /([\d\.]+)K/i then ($1.to_f).round
-				when /([\d\.]+)M/i then ($1.to_f * 1024).round
-				when /([\d\.]+)G/i then ($1.to_f * 1024 * 1024).round
-				else (string.to_f / 1024).ceil
+				case size_string.strip
+				when /([\d\.]+)K/i then ($1.to_f * 1024).round
+				when /([\d\.]+)M/i then ($1.to_f * 1024 * 1024).round
+				when /([\d\.]+)G/i then ($1.to_f * 1024 * 1024 * 1024).round
+				else (size_string.to_f).ceil
 				end
 			end
 			
+			# Regex for vmmap region lines: region name, address range, [virtual resident dirty swap], permissions, SM=sharing_mode.
 			LINE = /\A
 				\s*
 				(?<region_name>.+?)\s+
@@ -49,26 +39,24 @@ module Process
 				SM=(?<sharing_mode>\w+)
 			/x
 			
-			# Capture memory usage for the given process IDs.
+			# Capture memory usage by running vmmap for the given pid and summing region sizes. Proportional size is estimated as resident_size / count (Darwin has no PSS).
+			# @parameter pid [Integer] Process ID.
+			# @parameter count [Integer] Number of processes for proportional estimate (default: 1).
+			# @returns [Memory | Nil]
 			def self.capture(pid, count: 1, **options)
 				IO.popen(["vmmap", pid.to_s], "r") do |io|
 					usage = Memory.zero
-					
 					io.each_line do |line|
 						if match = LINE.match(line)
 							usage.map_count += 1
-							
 							virtual_size = parse_size(match[:virtual_size])
 							resident_size = parse_size(match[:resident_size])
 							dirty_size = parse_size(match[:dirty_size])
 							swap_size = parse_size(match[:swap_size])
-							
 							usage.resident_size += resident_size
 							usage.swap_size += swap_size
 							
-							# Private vs. Shared memory
-							# COW=copy_on_write PRV=private NUL=empty ALI=aliased 
-							# SHM=shared ZER=zero_filled S/A=shared_alias
+							# Private vs. Shared memory: COW=copy_on_write PRV=private NUL=empty ALI=aliased SHM=shared ZER=zero_filled S/A=shared_alias
 							case match[:sharing_mode]
 							when "PRV"
 								usage.private_clean_size += resident_size - dirty_size
@@ -85,10 +73,8 @@ module Process
 						end
 					end
 					
-					if usage.map_count.zero?
-						# vmap might not fail, but also might not return any data.
-						return nil
-					end
+					# vmmap might not fail, but also might not return any data.
+					return nil if usage.map_count.zero?
 					
 					# Darwin does not expose proportional memory usage, so we guess based on the number of processes. Yes, this is a terrible hack, but it's the most reasonable thing to do given the constraints:
 					usage.proportional_size = usage.resident_size / count
@@ -101,29 +87,24 @@ module Process
 				return nil
 			end
 		end
+	end
+end
+
+# Wire Memory.capture and Memory.supported? to this implementation when vmmap is executable.
+if Process::Metrics::Memory::Darwin.supported?
+	class << Process::Metrics::Memory
+		# Whether memory capture is supported on this platform.
+		# @returns [Boolean] True if vmmap is available.
+		def supported?
+			true
+		end
 		
-		if Memory::Darwin.supported?
-			class << Memory
-				# Whether memory capture is supported on this platform.
-				# @returns [Boolean] True if vmmap is available.
-				def supported?
-					return true
-				end
-				
-				# Get total system memory size.
-				# @returns [Integer] Total memory in kilobytes.
-				def total_size
-					return Memory::Darwin.total_size
-				end
-				
-				# Capture memory metrics for a process.
-				# @parameter pid [Integer] The process ID.
-				# @parameter options [Hash] Additional options (e.g., count for proportional estimates).
-				# @returns [Memory] A Memory instance with captured metrics.
-				def capture(...)
-					return Memory::Darwin.capture(...)
-				end
-			end
+		# Capture memory metrics for a process.
+		# @parameter pid [Integer] The process ID.
+		# @parameter options [Hash] Additional options (e.g. count for proportional estimates).
+		# @returns [Memory | Nil] A Memory instance with captured metrics.
+		def capture(...)
+			Process::Metrics::Memory::Darwin.capture(...)
 		end
 	end
 end

data/lib/process/metrics/memory/linux.rb

@@ -1,21 +1,22 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2025, by Samuel Williams.
+# Copyright, 2025-2026, by Samuel Williams.
 
 module Process
 	module Metrics
-		# Linux implementation of memory metrics using `/proc/[pid]/smaps` and `/proc/[pid]/stat`.
+		# Linux implementation of per-process memory metrics using `/proc/[pid]/smaps` or `/proc/[pid]/smaps_rollup`, and `/proc/[pid]/stat` for fault counters.
+		# Prefers smaps_rollup when readable (single summary); otherwise falls back to full smaps and counts maps from /proc/[pid]/maps.
 		class Memory::Linux
-			# Extract minor/major page fault counters from `/proc/[pid]/stat` and assign to usage.
-			# @parameter pid [Integer] The process ID.
-			# @parameter usage [Memory] The Memory instance to populate with fault counters.
+			# Extract minor and major page fault counters from `/proc/[pid]/stat` (proc(5): fields 10=minflt, 12=majflt) and assign to usage.
+			# @parameter pid [Integer] Process ID.
+			# @parameter usage [Memory] Memory instance to populate with minor_faults and major_faults.
 			def self.capture_faults(pid, usage)
-				stat = File.read("/proc/#{pid}/stat")
+				stat_content = File.read("/proc/#{pid}/stat")
 				# The comm field can contain spaces and parentheses; find the closing ')':
-				rparen_index = stat.rindex(")")
-				return unless rparen_index
-				fields = stat[(rparen_index+2)..-1].split(/\s+/)
+				closing_paren_index = stat_content.rindex(")")
+				return unless closing_paren_index
+				fields = stat_content[(closing_paren_index + 2)..].split(/\s+/)
 				# proc(5): field 10=minflt, 12=majflt; our fields array is 0-indexed from field 3.
 				usage.minor_faults = fields[10-3].to_i
 				usage.major_faults = fields[12-3].to_i
@@ -23,16 +24,7 @@ module Process
 				# Ignore.
 			end
 			
-			# @returns [Numeric] Total memory size in kilobytes.
-			def self.total_size
-				File.read("/proc/meminfo").each_line do |line|
-					if /MemTotal:\s+(?<total>\d+) kB/ =~ line
-						return total.to_i
-					end
-				end
-			end
-			
-			# The fields that will be extracted from the `smaps` data.
+			# Mapping from smaps/smaps_rollup line names to Memory struct members (values in kB, converted to bytes when parsing).
 			SMAP = {
 				"Rss" => :resident_size,
 				"Pss" => :proportional_size,
@@ -52,22 +44,28 @@ module Process
 					true
 				end
 				
-				# Capture memory usage for the given process IDs.
-				def self.capture(pid, **options)
+				# Capture memory usage from /proc/[pid]/smaps_rollup and /proc/[pid]/maps. Optionally fill fault counters from /proc/[pid]/stat.
+				# @parameter pid [Integer] Process ID.
+				# @parameter faults [Boolean] Whether to capture minor_faults and major_faults (default: true).
+				# @returns [Memory | Nil]
+				def self.capture(pid, faults: true, **options)
 					File.open("/proc/#{pid}/smaps_rollup") do |file|
 						usage = Memory.zero
-						
 						file.each_line do |line|
 							if /(?<name>.*?):\s+(?<value>\d+) kB/ =~ line
 								if key = SMAP[name]
-									usage[key] += value.to_i
+									# Convert from kilobytes to bytes:
+									usage[key] += value.to_i * 1024
 								end
 							end
 						end
 						
 						usage.map_count += File.readlines("/proc/#{pid}/maps").size
-						# Also capture fault counters:
-						self.capture_faults(pid, usage)
+						
+						# Also capture fault counters if requested:
+						if faults
+							self.capture_faults(pid, usage)
+						end
 						
 						return usage
 					end
@@ -81,17 +79,20 @@ module Process
 					true
 				end
 				
-				# Capture memory usage for the given process IDs.
-				def self.capture(pid, **options)
+				# Capture memory usage from /proc/[pid]/smaps (and map count from VmFlags) and /proc/[pid]/maps. Optionally fill fault counters from /proc/[pid]/stat.
+				# @parameter pid [Integer] Process ID.
+				# @parameter faults [Boolean] Whether to capture minor_faults and major_faults (default: true).
+				# @returns [Memory | Nil]
+				def self.capture(pid, faults: true, **options)
 					File.open("/proc/#{pid}/smaps") do |file|
 						usage = Memory.zero
-						
 						file.each_line do |line|
 							# The format of this is fixed according to:
 							# https://github.com/torvalds/linux/blob/351c8a09b00b5c51c8f58b016fffe51f87e2d820/fs/proc/task_mmu.c#L804-L814
 							if /(?<name>.*?):\s+(?<value>\d+) kB/ =~ line
 								if key = SMAP[name]
-									usage[key] += value.to_i
+									# Convert from kilobytes to bytes:
+									usage[key] += value.to_i * 1024
 								end
 							elsif /VmFlags:\s+(?<flags>.*)/ =~ line
 								# It should be possible to extract the number of fibers and each fiber's memory usage.
@@ -100,8 +101,10 @@ module Process
 							end
 						end
 						
-						# Also capture fault counters:
-						self.capture_faults(pid, usage)
+						# Also capture fault counters if requested:
+						if faults
+							self.capture_faults(pid, usage)
+						end
 						
 						return usage
 					end
@@ -115,29 +118,25 @@ module Process
 				end
 			end
 		end
+	end
+end
+
+# Wire Memory.capture and Memory.supported? to this implementation when smaps or smaps_rollup is readable.
+if Process::Metrics::Memory::Linux.supported?
+	class << Process::Metrics::Memory
+		# Whether memory capture is supported on this platform.
+		# @returns [Boolean] True if /proc/[pid]/smaps or smaps_rollup is readable.
+		def supported?
+			true
+		end
 		
-		if Memory::Linux.supported?
-			class << Memory
-				# Whether memory capture is supported on this platform.
-				# @returns [Boolean] True if /proc/[pid]/smaps or smaps_rollup is readable.
-				def supported?
-					return true
-				end
-				
-				# Get total system memory size.
-				# @returns [Integer] Total memory in kilobytes.
-				def total_size
-					return Memory::Linux.total_size
-				end
-				
-				# Capture memory metrics for a process.
-				# @parameter pid [Integer] The process ID.
-				# @parameter options [Hash] Additional options.
-				# @returns [Memory] A Memory instance with captured metrics.
-				def capture(...)
-					return Memory::Linux.capture(...)
-				end
-			end
+		# Capture memory metrics for a process.
+		# @parameter pid [Integer] The process ID.
+		# @parameter faults [Boolean] Whether to capture fault counters (default: true).
+		# @parameter options [Hash] Additional options.
+		# @returns [Memory | Nil] A Memory instance with captured metrics.
+		def capture(...)
+			Process::Metrics::Memory::Linux.capture(...)
 		end
 	end
 end

data/lib/process/metrics/memory.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2019-2025, by Samuel Williams.
+# Copyright, 2019-2026, by Samuel Williams.
 
 require "json"
+require_relative "host/memory"
 
 module Process
 	module Metrics
-		# Represents memory usage for a process, sizes are in kilobytes.
+		# Represents memory usage for a process, sizes are in bytes.
 		class Memory < Struct.new(:map_count, :resident_size, :proportional_size, :shared_clean_size, :shared_dirty_size, :private_clean_size, :private_dirty_size, :referenced_size, :anonymous_size, :swap_size, :proportional_swap_size, :minor_faults, :major_faults)
 			
 			alias as_json to_h
@@ -33,6 +34,12 @@ module Process
 				self.new(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
 			end
 			
+			# Total system/host memory in bytes. Delegates to Host::Memory.capture.
+			# @returns [Integer | Nil]
+			def self.total_size
+				Host::Memory.capture&.total
+			end
+			
 			# Whether the memory usage can be captured on this system.
 			def self.supported?
 				false
@@ -46,5 +53,8 @@ module Process
 	end
 end
 
-require_relative "memory/linux"
-require_relative "memory/darwin"
+if RUBY_PLATFORM.include?("linux")
+	require_relative "memory/linux"
+elsif RUBY_PLATFORM.include?("darwin")
+	require_relative "memory/darwin"
+end

data/lib/process/metrics/version.rb

@@ -7,6 +7,6 @@
 module Process
 	# @namespace
 	module Metrics
-		VERSION = "0.8.0"
+		VERSION = "0.10.0"
 	end
 end

data/license.md

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright, 2019-2025, by Samuel Williams.  
+Copyright, 2019-2026, by Samuel Williams.  
 Copyright, 2024, by Adam Daniels.  
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

data/readme.md

@@ -16,6 +16,22 @@ Please see the [project documentation](https://socketry.github.io/process-metric
 
 Please see the [project releases](https://socketry.github.io/process-metrics/releases/index) for all releases.
 
+### v0.10.0
+
+  - **Host::Memory**: New per-host struct `Process::Metrics::Host::Memory` with `total`, `used`, `free`, `swap_total`, `swap_used` (all bytes). Use `Host::Memory.capture` to get a snapshot; `.supported?` indicates platform support.
+
+### v0.9.0
+
+  - `Process::Metrics::Memory.total_size` takes into account cgroup limits.
+  - On Linux, capturing faults is optional, controlled by `capture(faults: true/false)`.
+  - Report all sizes in bytes for consistency.
+
+### v0.8.0
+
+  - Kill `ps` before waiting to avoid hanging when using the process-status backend.
+  - Ignore `Errno::EACCES` when reading process information.
+  - Cleaner process management for the `ps`-based capture path.
+
 ### v0.7.0
 
   - Be more proactive about returning nil if memory capture failed.
@@ -55,24 +71,6 @@ Please see the [project releases](https://socketry.github.io/process-metrics/rel
   - Added missing dependencies: `bake-test-external` and `json` gem.
   - Added summary lines for PSS (Proportional Set Size) and USS (Unique Set Size).
 
-### v0.2.1
-
-  - Added missing dependency to gemspec.
-  - Added example of command line usage to documentation.
-  - Renamed `rsz` to `rss` (Resident Set Size) for consistency across Darwin and Linux platforms.
-
-### v0.2.0
-
-  - Added `process-metrics` command line interface for monitoring processes.
-  - Implemented structured data using Ruby structs for better performance and clarity.
-  - Added documentation about PSS (Proportional Set Size) and USS (Unique Set Size) metrics.
-
-### v0.1.1
-
-  - Removed `Gemfile.lock` from version control.
-  - Fixed process metrics to exclude the `ps` command itself from measurements.
-  - Fixed documentation formatting issues.
-
 ## Contributing
 
 We welcome contributions to this project.

data/releases.md

@@ -1,5 +1,21 @@
 # Releases
 
+## v0.10.0
+
+  - **Host::Memory**: New per-host struct `Process::Metrics::Host::Memory` with `total`, `used`, `free`, `swap_total`, `swap_used` (all bytes). Use `Host::Memory.capture` to get a snapshot; `.supported?` indicates platform support.
+
+## v0.9.0
+
+  - `Process::Metrics::Memory.total_size` takes into account cgroup limits.
+  - On Linux, capturing faults is optional, controlled by `capture(faults: true/false)`.
+  - Report all sizes in bytes for consistency.
+
+## v0.8.0
+
+  - Kill `ps` before waiting to avoid hanging when using the process-status backend.
+  - Ignore `Errno::EACCES` when reading process information.
+  - Cleaner process management for the `ps`-based capture path.
+
 ## v0.7.0
 
   - Be more proactive about returning nil if memory capture failed.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: process-metrics
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -94,6 +94,11 @@ files:
 - lib/process/metrics/command/summary.rb
 - lib/process/metrics/command/top.rb
 - lib/process/metrics/general.rb
+- lib/process/metrics/general/linux.rb
+- lib/process/metrics/general/process_status.rb
+- lib/process/metrics/host/memory.rb
+- lib/process/metrics/host/memory/darwin.rb
+- lib/process/metrics/host/memory/linux.rb
 - lib/process/metrics/memory.rb
 - lib/process/metrics/memory/darwin.rb
 - lib/process/metrics/memory/linux.rb
@@ -122,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Provide detailed OS-specific process metrics.
 test_files: []