memory-leak 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ab8d8ab5e5ebff81f2847704ece1e34c20c71aa35a361caea8eafccc4b39f6f
-  data.tar.gz: e0a1dce4599132dc7a5aff55d1d639efb50e4d5f2b7c7f0f81289100471c8682
+  metadata.gz: 37f012e5be6339c13ac1ed6be815e5f88d076b0c32809b65390f3666fa80511a
+  data.tar.gz: 7be83bdf7182cff46548332674a1cb1faa3aeedf3689d8d02ba741d6720a9f11
 SHA512:
-  metadata.gz: cff70665edfcdf6d0e3d6ed7510586deb57fbd04f16476e5795acb73635688dec1f455a343b7bd3ba595a1e00a84dd65a34b658fecb11ad0b9fb2ff093e174e5
-  data.tar.gz: 9a09bb3be13452c240289f6d5433fc11c46213d987ac2abea1db6f6c2484f8453670413d9a48555e57d9cbbbd0918d91049ebb4d05306f74fa683efd8e839829
+  metadata.gz: 4dd8a56dd4dd2b812a42cb0537ed701f91f0ffe75b53020805d846dd89e009240551b05f918f5d2d251cc17edf7b92dea84651c1240698052976cb444fc35121
+  data.tar.gz: 35674c676112e87c1aefc0cb36078dc6da5f927787bd9529d09c27a35dba8141fccea77f410bf61807c817054913582af85b80f788c5e92b4e564c9fb6a4f431

data/lib/memory/leak/cluster.rb

@@ -57,26 +57,46 @@ module Memory
 			
 			# Apply the memory limit to the cluster. If the total memory usage exceeds the limit, yields each process ID and monitor in order of maximum memory usage, so that they could be terminated and/or removed.
 			#
-			# @yields {|process_id, monitor| ...} each process ID and monitor in order of maximum memory usage, return true if it was terminated to adjust memory usage.
-			def apply_limit!(total_size_limit = @total_size_limit)
-				@total_size = @processes.values.map(&:current_size).sum
+			# Total cluster memory usage is calculated as: max(shared memory usages) + sum(private memory usages)
+			# This accounts for shared memory being counted only once across all processes.
+			#
+			# @parameter block [Proc] Required block to handle process termination.
+			# @yields {|process_id, monitor, total_size| ...} each process ID and monitor in order of maximum memory usage, return true if it was terminated to adjust memory usage.
+			# @raises [ArgumentError] if no block is provided.
+			protected def apply_limit!(total_size_limit = @total_size_limit, &block)
+				# Only processes with known private size can be considered:
+				monitors = @processes.values.select do |monitor|
+					monitor.current_private_size != nil
+				end
+				
+				maximum_shared_size = monitors.map(&:current_shared_size).max || 0
+				sum_private_size = monitors.map(&:current_private_size).sum
+				
+				@total_size = maximum_shared_size + sum_private_size
 				
 				if @total_size > total_size_limit
-					Console.warn(self, "Total memory usage exceeded limit.", total_size: @total_size, total_size_limit: total_size_limit)
+					Console.warn(self, "Total memory usage exceeded limit.", total_size: @total_size, total_size_limit: total_size_limit, maximum_shared_size: maximum_shared_size, sum_private_size: sum_private_size)
 				else
 					return false
 				end
 				
-				sorted = @processes.sort_by do |process_id, monitor|
-					-monitor.current_size
+				# Only process monitors where we can compute private size:
+				monitors.sort_by! do |monitor|
+					-monitor.current_private_size
 				end
 				
-				sorted.each do |process_id, monitor|
+				monitors.each do |monitor|
 					if @total_size > total_size_limit
-						yield(process_id, monitor, @total_size)
+						# Capture values before yielding (process may be removed):
+						private_size = monitor.current_private_size
+						
+						yield(monitor.process_id, monitor, @total_size)
 						
-						# For the sake of the calculation, we assume that the process has been terminated:
-						@total_size -= monitor.current_size
+						# Incrementally update: subtract this process's contribution
+						sum_private_size -= private_size
+						
+						# We use the computed maximum shared size, even if it might not be correct, as it is good enough for enforcing the limits and recalculating it is non-trivial.
+						@total_size = maximum_shared_size + sum_private_size
 					else
 						break
 					end
@@ -85,11 +105,7 @@ module Memory
 			
 			# Sample the memory usage of all processes in the cluster.
 			def sample!
-				System.memory_usages(@processes.keys) do |process_id, memory_usage|
-					if monitor = @processes[process_id]
-						monitor.sample!(memory_usage)
-					end
-				end
+				@processes.each_value(&:sample!)
 			end
 			
 			# Check all processes in the cluster for memory leaks.
@@ -110,11 +126,13 @@ module Memory
 				
 				if block_given?
 					leaking.each(&block)
+					
+					# Finally, apply any per-cluster memory limits:
+					if @total_size_limit
+						apply_limit!(@total_size_limit, &block)
+					end
 				end
 				
-				# Finally, apply any per-cluster memory limits:
-				apply_limit!(@total_size_limit, &block) if @total_size_limit
-				
 				return leaking
 			end
 		end

data/lib/memory/leak/monitor.rb

@@ -4,7 +4,7 @@
 # Copyright, 2025, by Samuel Williams.
 
 require "console"
-require_relative "system"
+require "process/metrics/memory"
 
 module Memory
 	module Leak
@@ -35,6 +35,8 @@ module Memory
 				
 				@sample_count = 0
 				@current_size = nil
+				@current_shared_size = nil
+				@current_private_size = nil
 				@maximum_size = maximum_size
 				@maximum_size_limit = maximum_size_limit
 				@maximum_observed_size = nil
@@ -50,6 +52,8 @@ module Memory
 					process_id: @process_id,
 					sample_count: @sample_count,
 					current_size: @current_size,
+					current_shared_size: @current_shared_size,
+					current_private_size: @current_private_size,
 					maximum_size: @maximum_size,
 					maximum_size_limit: @maximum_size_limit,
 					threshold_size: @threshold_size,
@@ -81,9 +85,19 @@ module Memory
 			# @attribute [Numeric] The limit for the number of process size increases, before we assume a memory leak.
 			attr_accessor :increase_limit
 			
+			# @attribute [Integer] The last sampled shared memory size in bytes.
+			attr_accessor :current_shared_size
+			
+			# @attribute [Integer] The last sampled private memory size in bytes.
+			attr_accessor :current_private_size
+			
 			# @returns [Integer] Ask the system for the current memory usage.
 			def memory_usage
-				System.memory_usage(@process_id)
+				if metrics = Process::Metrics::Memory.capture(@process_id, faults: false)
+					return metrics.resident_size
+				else
+					return 0
+				end
 			end
 			
 			# @attribute [Integer] The number of samples taken.
@@ -129,10 +143,19 @@ module Memory
 			# Capture a memory usage sample and yield if a memory leak is detected.
 			#
 			# @yields {|sample, monitor| ...} If a memory leak is detected.
-			def sample!(memory_usage = self.memory_usage)
+			def sample!
 				@sample_count += 1
 				
-				self.current_size = memory_usage
+				if metrics = Process::Metrics::Memory.capture(@process_id, faults: false)
+					self.current_size = metrics.resident_size
+					self.current_shared_size = metrics.shared_clean_size
+					self.current_private_size = metrics.private_clean_size + metrics.private_dirty_size
+				else
+					# Process doesn't exist or we can't access it - use fallback values
+					self.current_size = memory_usage
+					self.current_shared_size = 0
+					self.current_private_size = 0
+				end
 				
 				if @maximum_observed_size
 					delta = @current_size - @maximum_observed_size
@@ -142,7 +165,7 @@ module Memory
 						@maximum_observed_size = @current_size
 						@increase_count += 1
 						
-						Console.debug(self, "Heap size increased.", maximum_observed_size: @maximum_observed_size, count: @count)
+						Console.debug(self, "Heap size increased.", maximum_observed_size: @maximum_observed_size, count: @increase_count)
 					end
 				else
 					Console.debug(self, "Initial heap size captured.", current_size: @current_size)

data/lib/memory/leak/version.rb

@@ -5,6 +5,6 @@
 
 module Memory
 	module Leak
-		VERSION = "0.7.0"
+		VERSION = "0.9.0"
 	end
 end

data/license.md

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright, 2025, by Samuel Williams.  
+Copyright, 2025-2026, by Samuel Williams.  
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/readme.md

@@ -12,6 +12,15 @@ Please see the [project documentation](https://socketry.github.io/memory-leak/)
 
 Please see the [project releases](https://socketry.github.io/memory-leak/releases/index) for all releases.
 
+### v0.9.0
+
+  - Use `process-metrics` gem for accessing both private and shared memory where possible.
+  - Better implementation of cluster `total_size_limit` that takes into account shared and private memory.
+
+### v0.8.0
+
+  - `Memory::Leak::System.total_memory_size` now considers `cgroup` memory limits.
+
 ### v0.7.0
 
   - Make both `increase_limit` and `maximum_size_limit` optional (if `nil`).

data/releases.md

@@ -1,5 +1,14 @@
 # Releases
 
+## v0.9.0
+
+  - Use `process-metrics` gem for accessing both private and shared memory where possible.
+  - Better implementation of cluster `total_size_limit` that takes into account shared and private memory.
+
+## v0.8.0
+
+  - `Memory::Leak::System.total_memory_size` now considers `cgroup` memory limits.
+
 ## v0.7.0
 
   - Make both `increase_limit` and `maximum_size_limit` optional (if `nil`).

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memory-leak
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -37,7 +37,21 @@ cert_chain:
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: process-metrics
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -45,7 +59,6 @@ files:
 - lib/memory/leak.rb
 - lib/memory/leak/cluster.rb
 - lib/memory/leak/monitor.rb
-- lib/memory/leak/system.rb
 - lib/memory/leak/version.rb
 - license.md
 - readme.md
@@ -70,7 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.3
 specification_version: 4
 summary: A memory leak monitor.
 test_files: []

data/lib/memory/leak/system.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the MIT License.
-# Copyright, 2025, by Samuel Williams.
-
-require "console"
-
-module Memory
-	module Leak
-		# System-specific memory information.
-		module System
-			if File.exist?("/proc/meminfo")
-				# @returns [Integer] The total memory size in bytes.
-				def self.total_memory_size
-					File.foreach("/proc/meminfo") do |line|
-						if /MemTotal:\s*(?<total>\d+)\s*kB/ =~ line
-							return total.to_i * 1024
-						end
-					end
-				end
-			elsif RUBY_PLATFORM =~ /darwin/
-				# @returns [Integer] The total memory size in bytes.
-				def self.total_memory_size
-					IO.popen(["sysctl", "hw.memsize"], "r") do |io|
-						io.each_line do |line|
-							if /hw.memsize:\s*(?<total>\d+)/ =~ line
-								return total.to_i
-							end
-						end
-					end
-				end
-			end
-			
-			# Get the memory usage of the given process IDs.
-			#
-			# @parameter process_ids [Array(Integer)] The process IDs to monitor.
-			# @returns [Array(Tuple(Integer, Integer))] The memory usage of the given process IDs.
-			def self.memory_usages(process_ids)
-				return to_enum(__method__, process_ids) unless block_given?
-				
-				if process_ids.any?
-					IO.popen(["ps", "-o", "pid=,rss=", "-p", process_ids.join(",")]) do |io|
-						io.each_line.map(&:split).each do |process_id, size|
-							yield process_id.to_i, size.to_i * 1024
-						end
-					end
-				end
-			end
-			
-			# Get the memory usage of the given process IDs.
-			#
-			# @parameter process_ids [Array(Integer)] The process IDs to monitor.
-			# @returns [Array(Tuple(Integer, Integer))] The memory usage of the given process IDs.
-			def self.memory_usage(process_id)
-				IO.popen(["ps", "-o", "rss=", "-p", process_id.to_s]) do |io|
-					return io.read.to_i * 1024
-				end
-			end
-		end
-	end
-end