Linux specific tests.

Author: samuel-williams-shopify

lib/process/metrics/general/linux.rb

@@ -51,14 +51,14 @@ def self.capture(pid: nil, ppid: nil, memory: Memory.supported?)
 
 					comm = stat[1...rparen]
 					fields = stat[(rparen + 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=20, vsz=21, rss=22
+					# 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.
 					ppid_val = fields[1].to_i
 					pgrp = fields[2].to_i
 					utime = fields[11].to_i
 					stime = fields[12].to_i
-					starttime = fields[20].to_i
-					vsz = fields[21].to_i
-					rss_pages = fields[22].to_i
+					starttime = fields[19].to_i
+					vsz = fields[20].to_i
+					rss_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

test/process/general.rb

@@ -28,29 +28,29 @@
 		it "can extract memory usage" do
 			expect(capture[pid].memory_usage).to be > 0.0
 		end
-
+		
 		it "sets parent_process_id and process_group_id" do
 			process = capture[pid]
 			expect(process.process_id).to be == pid
 			expect(process.parent_process_id).to be_a(Integer)
 			expect(process.process_group_id).to be_a(Integer)
 		end
 	end
-
+	
 	with ".capture with ppid only" do
 		def before
 			super
 			@child_pid = Process.spawn("sleep 10")
 		end
-
+		
 		def after(error = nil)
 			super
 			Process.kill(:TERM, @child_pid) if @child_pid
 			Process.wait(@child_pid) if @child_pid
 		end
-
-		let(:capture) { Process::Metrics::General.capture(ppid: Process.pid) }
-
+		
+		let(:capture) {Process::Metrics::General.capture(ppid: Process.pid)}
+		
 		it "includes descendants of the given ppid" do
 			expect(capture).to be(:include?, @child_pid)
 			child = capture[@child_pid]
@@ -59,7 +59,7 @@ def after(error = nil)
 			expect(child.parent_process_id).to be == Process.pid
 		end
 	end
-
+	
 	with ".capture with parent pid" do
 		def before
 			super
@@ -92,7 +92,7 @@ def after(error = nil)
 			expect(command[:processor_time]).to be >= 0.0
 			expect(command[:processor_utilization]).to be >= 0.0
 		end
-
+		
 		it "sets parent_process_id and process_group_id on child" do
 			child = capture[@pid]
 			expect(child).not.to be_nil

test/process/general/linux.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024-2025, by Samuel Williams.
+
+require "process/metrics"
+# Load ProcessStatus backend so we can compare General (Linux) vs General::ProcessStatus.
+require "process/metrics/general/process_status"
+
+describe Process::Metrics::General do
+	with "Linux backend matches ProcessStatus backend" do
+		def log_backend_comparison(linux, ps)
+			$stderr.puts "[process-metrics] RUBY_PLATFORM=#{RUBY_PLATFORM.inspect}"
+			$stderr.puts "[process-metrics] Linux keys: #{linux.keys.sort.inspect}"
+			$stderr.puts "[process-metrics] ps keys: #{ps.keys.sort.inspect}"
+			first = true
+			linux.each_key do |p|
+				l = linux[p]
+				ps_process = ps[p]
+				$stderr.puts "[process-metrics] pid=#{p}"
+				$stderr.puts "[process-metrics]   Linux:  process_id=#{l.process_id} ppid=#{l.parent_process_id} pgid=#{l.process_group_id} vsz=#{l.virtual_size} rss=#{l.resident_size} command=#{l.command.inspect} processor_time=#{l.processor_time} elapsed_time=#{l.elapsed_time}"
+				if ps_process
+					$stderr.puts "[process-metrics]   ps:     process_id=#{ps_process.process_id} ppid=#{ps_process.parent_process_id} pgid=#{ps_process.process_group_id} vsz=#{ps_process.virtual_size} rss=#{ps_process.resident_size} command=#{ps_process.command.inspect} processor_time=#{ps_process.processor_time} elapsed_time=#{ps_process.elapsed_time}"
+					# Per-field match/mismatch (proc(5) stat uses indices 19,20,21 for starttime,vsz,rss after comm).
+					%i[process_id parent_process_id process_group_id virtual_size resident_size command processor_time elapsed_time].each do |field|
+						lv = l[field]
+						pv = ps_process[field]
+						match = lv == pv
+						if !match && field == :resident_size && lv.is_a?(Integer) && pv.is_a?(Integer)
+							rss_tol = [lv * 0.05, 512 * 1024].max
+							match = (lv - pv).abs <= rss_tol
+						end
+						if !match && (field == :processor_time || field == :elapsed_time) && lv.is_a?(Numeric) && pv.is_a?(Numeric)
+							match = (lv - pv).abs < 1.0
+						end
+						$stderr.puts "[process-metrics]   #{field}: #{match ? 'ok' : "MISMATCH linux=#{lv.inspect} ps=#{pv.inspect}"}"
+					end
+				else
+					$stderr.puts "[process-metrics]   ps:     (nil)"
+				end
+				# Log raw /proc/pid/stat tail (fields after ') ') for first process to verify field indices.
+				if first && File.readable?("/proc/#{p}/stat")
+					stat = File.read("/proc/#{p}/stat")
+					rparen = stat.rindex(")")
+					if rparen
+						tail = stat[(rparen + 2)..]
+						fields = tail.split(/\s+/)
+						$stderr.puts "[process-metrics]   /proc/#{p}/stat: #{fields.size} fields after ') '; indices 19,20,21 => starttime=#{fields[19].inspect} vsz=#{fields[20].inspect} rss=#{fields[21].inspect}"
+					end
+					first = false
+				end
+			end
+		end
+
+		def assert_backends_match(linux, ps)
+			log_backend_comparison(linux, ps)
+			expect(linux.keys.sort).to be == ps.keys.sort
+			linux.each_key do |p|
+				l = linux[p]
+				ps_process = ps[p]
+				expect(ps_process.nil?).to be == false
+				expect(l.process_id).to be == ps_process.process_id
+				expect(l.parent_process_id).to be == ps_process.parent_process_id
+				expect(l.process_group_id).to be == ps_process.process_group_id
+				expect(l.virtual_size).to be == ps_process.virtual_size
+				# RSS can differ slightly: /proc uses pages, ps may use KiB; read at different times.
+				rss_delta = (l.resident_size - ps_process.resident_size).abs
+				rss_tolerance = [l.resident_size * 0.05, 512 * 1024].max
+				expect(rss_delta).to be <= rss_tolerance
+				expect(l.command).to be == ps_process.command
+				expect((l.processor_time - ps_process.processor_time).abs).to be < 1.0
+				expect((l.elapsed_time - ps_process.elapsed_time).abs).to be < 1.0
+			end
+		end
+
+		it "single pid capture matches" do
+			skip "Linux with ps required" unless RUBY_PLATFORM.include?("linux") && Process::Metrics::General::ProcessStatus.supported?
+
+			pid = Process.pid
+			linux = Process::Metrics::General.capture(pid: pid, memory: false)
+			ps = Process::Metrics::General::ProcessStatus.capture(pid: pid, memory: false)
+			assert_backends_match(linux, ps)
+		end
+
+		it "pid and ppid capture matches" do
+			skip "Linux with ps required" unless RUBY_PLATFORM.include?("linux") && Process::Metrics::General::ProcessStatus.supported?
+
+			child_pid = Process.spawn("sleep 10")
+			begin
+				linux = Process::Metrics::General.capture(pid: child_pid, ppid: child_pid, memory: false)
+				ps = Process::Metrics::General::ProcessStatus.capture(pid: child_pid, ppid: child_pid, memory: false)
+				assert_backends_match(linux, ps)
+			ensure
+				Process.kill(:TERM, child_pid)
+				Process.wait(child_pid)
+			end
+		end
+	end
+end