memory-leak 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e90479921bd01bec68994b554ea988197ba78cbf3051eef9fd7a379aff819ae3
-  data.tar.gz: 0d4e41b000ce59d1ce7ee614410e7a3a42c6133a6ad2ac537b79800b32fc6c8f
+  metadata.gz: 37f012e5be6339c13ac1ed6be815e5f88d076b0c32809b65390f3666fa80511a
+  data.tar.gz: 7be83bdf7182cff46548332674a1cb1faa3aeedf3689d8d02ba741d6720a9f11
 SHA512:
-  metadata.gz: 54b369c45a58a2d52671df46f08e8e949499973392147c07060e4a1ea171fbd21db0631ce9f595c30c3ebce04626eec83c9724a3458d6041524905a6272e3410
-  data.tar.gz: 6c1088a90a3581f1a91404d5d8c51480dd5029a5a65abfb76b47a5d6f9cc4265fc3c493e8f5b8617bb9e0e55db5f266c3c357021c6321ac0271917ae27fa9066
+  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.8.0"
+		VERSION = "0.9.0"
 	end
 end

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`).
@@ -21,13 +30,6 @@ Please see the [project releases](https://socketry.github.io/memory-leak/release
   - Added `sample_count` attribute to monitor to track number of samples taken.
   - `check!` method in cluster now returns an array of leaking monitors if no block is given.
   - `Cluster#check!` now invokes `Monitor#sample!` to ensure memory usage is updated before checking for leaks.
-    \=======
-
-### v0.8.0
-
-  - `Memory::Leak::System.total_memory_size` now considers `cgroup` memory limits.
-
-> > > > > > > Stashed changes
 
 ### v0.5.0
 

data/releases.md

@@ -1,6 +1,13 @@
 # Releases
 
-\<\<\<\<\<\<\< Updated upstream
+## 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
 
@@ -11,13 +18,6 @@
   - Added `sample_count` attribute to monitor to track number of samples taken.
   - `check!` method in cluster now returns an array of leaking monitors if no block is given.
   - `Cluster#check!` now invokes `Monitor#sample!` to ensure memory usage is updated before checking for leaks.
-    \=======
-
-## v0.8.0
-
-  - `Memory::Leak::System.total_memory_size` now considers `cgroup` memory limits.
-
-> > > > > > > Stashed changes
 
 ## v0.5.0
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memory-leak
 version: !ruby/object:Gem::Version
-  version: 0.8.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

data/lib/memory/leak/system.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the MIT License.
-# Copyright, 2025-2026, by Samuel Williams.
-
-require "console"
-
-module Memory
-	module Leak
-		# System-specific memory information.
-		module System
-			# Determine the total memory size in bytes. This is the maximum amount of memory that can be used by the current process. If running in a container, this may be limited by the container runtime (e.g. cgroups).
-			#
-			# @returns [Integer] The total memory size in bytes.
-			def self.total_memory_size
-				# Check for Kubernetes/cgroup memory limit first (cgroups v2):
-				if File.exist?("/sys/fs/cgroup/memory.max")
-					limit = File.read("/sys/fs/cgroup/memory.max").strip
-					# "max" means unlimited, fall through to other methods
-					if limit != "max"
-						return limit.to_i
-					end
-				end
-				
-				# Check for Kubernetes/cgroup memory limit (cgroups v1):
-				if File.exist?("/sys/fs/cgroup/memory/memory.limit_in_bytes")
-					limit = File.read("/sys/fs/cgroup/memory/memory.limit_in_bytes").strip
-					# Very large number (like 9223372036854771712) means unlimited, fall through
-					if limit.to_i < 2**50 # Reasonable upper bound for actual limits
-						return limit.to_i
-					end
-				end
-				
-				# Fall back to Linux system memory detection:
-				if File.exist?("/proc/meminfo")
-					File.foreach("/proc/meminfo") do |line|
-						if /MemTotal:\s*(?<total>\d+)\s*kB/ =~ line
-							return total.to_i * 1024
-						end
-					end
-				end
-				
-				# Fall back to macOS memory detection:
-				if RUBY_PLATFORM =~ /darwin/
-					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