linux_stat 0.5.1 → 0.6.4

data/lib/linux_stat/os.rb

@@ -1,6 +1,7 @@
 module LinuxStat
 	module OS
 		class << self
+			##
 			# Reads /etc/os-release and returns a Hash. For example:
 			#    {:NAME=>"Arch Linux", :PRETTY_NAME=>"Arch Linux", :ID=>"arch", :BUILD_ID=>"rolling", :ANSI_COLOR=>"38;2;23;147;209", :HOME_URL=>"https://www.archlinux.org/", :DOCUMENTATION_URL=>"https://wiki.archlinux.org/", :SUPPORT_URL=>"https://bbs.archlinux.org/", :BUG_REPORT_URL=>"https://bugs.archlinux.org/", :LOGO=>"archlinux"}
 			#
@@ -8,13 +9,15 @@ module LinuxStat
 			#
 			# The amount of data read is 4096 bytes. Any more than that will result in truncated output.
 			#
-			# The information is also cached, and once loaded, won't change in runtime. Because changing the /etc/lsb-release
+			# The information is also cached, and once loaded, won't change in runtime.
+			# Because changing the /etc/lsb-release
 			# isn't expected in runtime.
 			def os_release
 				# cached (memoized) ; as changing the value in runtime is unexpected
 				@@os_release ||= File.readable?('/etc/os-release') ? release('/etc/os-release') : {}
 			end
 
+			##
 			# Reads /etc/lsb-release and returns a Hash. For example:
 			#    {:LSB_VERSION=>"1.4", :DISTRIB_ID=>"Arch", :DISTRIB_RELEASE=>"rolling", :DISTRIB_DESCRIPTION=>"Arch Linux"}
 			#
@@ -22,14 +25,16 @@ module LinuxStat
 			#
 			# The amount of data read is 4096 bytes. Any more than that will result in truncated output.
 			#
-			# The information is also cached, and once loaded, won't change in runtime. Because changing the /etc/lsb-release
-			# isn't expected in runtime.
+			# The information is also cached, and once loaded, won't change in runtime.
+			# Because changing the /etc/lsb-release isn't expected in runtime.
 			def lsb_release
 				# cached (memoized) ; as changing the value in runtime is unexpected
 				@@lsb_release ||= File.readable?('/etc/lsb-release') ? release('/etc/lsb-release') : {}
 			end
 
+			##
 			# Reads /etc/lsb-release or /etc/os-release tries to get information about the distribution.
+			#
 			# If the information isn't available, it will read and return /etc/issue.
 			#
 			# The return type is String.
@@ -52,6 +57,7 @@ module LinuxStat
 				end
 			end
 
+			##
 			# Uses utsname.h to determine the machine
 			#
 			# It returns a String but if the info isn't available, it will return an empty String
@@ -59,6 +65,7 @@ module LinuxStat
 				@@machine ||= LinuxStat::Uname.machine
 			end
 
+			##
 			# Uses utsname.h to determine the system nodename
 			#
 			# It returns String but if the info isn't available, it will return an empty String
@@ -66,6 +73,7 @@ module LinuxStat
 				@@nodename ||= LinuxStat::Uname.nodename
 			end
 
+			##
 			# Reads /etc/hostname and returns the hostname.
 			#
 			# The return type is String.
@@ -78,8 +86,11 @@ module LinuxStat
 				end
 			end
 
+			##
 			# Reads ruby configuration and tries to guess if the system is 64 bit.
+			#
 			# If it fails then it runs utsname.h to guess the machine.
+			#
 			# It the machine is 64 bits, it will return 64, else it returns 32.
 			#
 			# The return type is strictly Integer and doesn't fail.
@@ -91,6 +102,7 @@ module LinuxStat
 				end
 			end
 
+			##
 			# Reads /proc/uptime and returns the system uptime:
 			#    {:hour=>10, :minute=>34, :second=>12.59}
 			#

data/lib/linux_stat/prettify_bytes.rb

@@ -0,0 +1,110 @@
+module LinuxStat
+	module PrettifyBytes
+		class << self
+			##
+			# Converts a number to decimal byte units and outputs with the metric prefix
+			# For example,
+			#
+			# LinuxStat::PrettifyBytes.convert_decimal(1000)
+			#
+			# => "1.0 kilobyte"
+			#
+			# LinuxStat::PrettifyBytes.convert_decimal(1000 ** 3)
+			#
+			# => "1.0 gigabyte"
+			#
+			# LinuxStat::PrettifyBytes.convert_decimal(1024 ** 3)
+			#
+			# => "1.07 gigabytes"
+			def convert_decimal(n)
+				@@d_units ||= %W(#{''} kilo mega giga tera peta exa zetta)
+					.map.with_index { |x, i| [x, 1000.**(i + 1)] }
+				unit = @@d_units.find { |x| n < x[1] } || ['yotta'.freeze, 10 ** 27]
+
+				converted = n.fdiv(unit[1] / 1000).round(2)
+				"#{pad_left(converted)} #{unit[0]}byte#{?s.freeze if converted != 1}"
+			end
+
+			# Converts a number to binary byte units and outputs with the IEC prefix
+			# For example,
+			#
+			# LinuxStat::PrettifyBytes.convert_binary(1000)
+			#
+			# => "1000.0 bytes"
+			#
+			# LinuxStat::PrettifyBytes.convert_binary(1000 ** 3)
+			#
+			# => "953.67 mebibytes"
+			#
+			# LinuxStat::PrettifyBytes.convert_binary(1024 ** 3)
+			#
+			# => "1.0 gibibyte"
+			def convert_binary(n)
+				@@b_units ||= %W(#{''} kibi mebi gibi tebi pebi exbi zebi)
+					.map.with_index { |x, i| [x, 1024.**(i + 1)] }
+				unit = @@b_units.find { |x| n < x[1] } || ['yobi'.freeze, 10 ** 27]
+
+				converted = n.fdiv(unit[1] / 1024).round(2)
+				"#{pad_left(converted)} #{unit[0]}byte#{?s.freeze if converted != 1}"
+			end
+
+			# Converts a number to decimal byte units
+			# For example,
+			#
+			# LinuxStat::PrettifyBytes.convert_short_decimal(1000)
+			#
+			# => "1.0 kB"
+			#
+			# LinuxStat::PrettifyBytes.convert_short_decimal(1000 ** 3)
+			#
+			# => "1.0 GB"
+			#
+			# LinuxStat::PrettifyBytes.convert_short_decimal(1024 ** 3)
+			#
+			# => "1.07 GB"
+			def convert_short_decimal(n)
+				@@sd_units ||= %W(#{''} k M G T P E Z)
+					.map.with_index { |x, i| [x, 1000.**(i + 1)] }
+				unit = @@sd_units.find { |x| n < x[1] } || [?Y.freeze, 10 ** 27]
+
+				converted = n.fdiv(unit[1] / 1000).round(2)
+				"#{pad_left(converted)} #{unit[0]}B"
+			end
+
+			##
+			# Converts a number to binary byte units
+			#
+			# For example,
+			#
+			# LinuxStat::PrettifyBytes.convert_short_binary(1000)
+			#
+			# => "1000 B"
+			#
+			# LinuxStat::PrettifyBytes.convert_short_binary(1000 ** 3)
+			#
+			# => "953.67 MiB"
+			#
+			# LinuxStat::PrettifyBytes.convert_short_binary(1024 ** 3)
+			#
+			# => "1.0 GiB"
+			def convert_short_binary(n)
+				return "#{n} B" if n < 1024
+
+				@@sb_units ||= %W(#{''} K M G T P E Z)
+					.map.with_index { |x, i| [x, 1024.**(i + 1)] }
+				unit = @@sb_units.find { |x| n < x[1] } || [?Y.freeze, 1024 ** 9]
+
+				converted = n.fdiv(unit[1] / 1024).round(2)
+				"#{pad_left(converted)} #{unit[0]}iB"
+			end
+
+			private
+			def pad_left(n, mantissa_length = 2)
+				n = n.round(mantissa_length)
+				exp, mant = n.to_s.split(?..freeze)
+				m = mant.length < mantissa_length ? mant + ?0.freeze * (mantissa_length - mant.length) : mant
+				exp + ?..freeze + m
+			end
+		end
+	end
+end

data/lib/linux_stat/process.rb

@@ -1,7 +1,9 @@
 module LinuxStat
 	module Process
 		class << self
+			##
 			# Returns the list of processes from /proc/.
+			#
 			# The return type is an Array of Integers.
 			def list
 				Dir['/proc/*'].select! { |x|
@@ -10,12 +12,15 @@ module LinuxStat
 				}.map! { |x| File.split(x)[-1].to_i }
 			end
 
+			##
 			# Counts and returns the total number of process running on the system.
+			#
 			# The return type is Integer.
 			def count
 				list.count
 			end
 
+			##
 			# Returns all the id of processes mapped with their names as a Hash.
 			def names
 				list.reduce({}) { |h, x|
@@ -27,6 +32,7 @@ module LinuxStat
 				}
 			end
 
+			##
 			# Returns all the id of processes mapped with their status as a Hash.
 			def types
 				list.reduce({}) { |h, x|
@@ -46,6 +52,7 @@ module LinuxStat
 				}
 			end
 
+			##
 			# Returns all the id of processes that are sleeping.
 			# The return type is an Array of Integers.
 			def sleeping
@@ -58,6 +65,7 @@ module LinuxStat
 				}
 			end
 
+			##
 			# Returns all the id of processes that are idle.
 			# The return type is an Array of Integers.
 			def idle
@@ -70,6 +78,7 @@ module LinuxStat
 				}
 			end
 
+			##
 			# Returns all the id of processes that are zombies.
 			# The return type is an Array of Integers.
 			def zombie
@@ -82,6 +91,7 @@ module LinuxStat
 				}
 			end
 
+			##
 			# Returns all the id of processes that are running.
 			# The return type is an Array of Integers.
 			def running

data/lib/linux_stat/process_info.rb

@@ -1,12 +1,20 @@
 module LinuxStat
 	module ProcessInfo
 		class << self
-			# total_io(pid = $$)
+			##
+			# = total_io(pid = $$)
+			#
 			# Where pid is the process ID.
+			#
 			# By default it is the id of the current process ($$)
 			#
 			# It retuns the total read/write caused by a process.
-			# The output is Hash. For example, a sample output:
+			#
+			# The output is Hash.
+			#
+			# For example:
+			#    LinuxStat::ProcessInfo.total_io
+			#
 			#    {:read_bytes=>0, :write_bytes=>0}
 			#
 			# The output is only based on the total disk IO the process has done.
@@ -28,12 +36,18 @@ module LinuxStat
 				out
 			end
 
-			# cmdline(pid = $$)
+			##
+			# = cmdline(pid = $$)
+			#
 			# Where pid is the process ID.
+			#
 			# By default it is the id of the current process ($$)
 			#
 			# It retuns the total command of the process.
-			# The output is String. For example, a sample output:
+			#
+			# The output is String. For example:
+			#    LinuxStat::ProcessInfo.cmdline
+			#
 			#    "ruby -r linux_stat -e p LinuxStat::ProcessInfo.cmdline"
 			#
 			# If the info isn't available it will return an empty frozen String.
@@ -46,12 +60,18 @@ module LinuxStat
 				_cmdline.tap(&:strip!)
 			end
 
-			# command_name(pid = $$)
+			##
+			# = command_name(pid = $$)
+			#
 			# Where pid is the process ID.
+			#
 			# By default it is the id of the current process ($$)
 			#
 			# It retuns the total command name of the process.
-			# The output is String. For example, a sample output:
+			#
+			# The output is String. For example:
+			#    LinuxStat::ProcessInfo.command_name
+			#
 			#    "ruby"
 			#
 			# If the info isn't available it will return an empty frozen String.
@@ -65,146 +85,166 @@ module LinuxStat
 				File.split(_cmdline.tap(&:strip!).split[0])[-1]
 			end
 
-			# mem_stat(pid = $$)
+			##
+			# = mem_stat(pid = $$)
+			#
 			# Where pid is the process ID.
+			#
 			# By default it is the id of the current process ($$)
 			#
 			# It retuns the memory, virtual memory, and resident memory of the process.
-			# All values are in Kilobytes.
 			#
-			# The output is a Hash. For example, a sample output:
-			#    {:memory=>8656, :virtual_memory=>78272, :resident_memory=>14072}
+			# All values are in kilobytes.
+			#
+			# The output is a Hash. For example:
+			#    LinuxStat::ProcessInfo.mem_stat
+			#
+			#    {:memory=>8515.584, :virtual_memory=>79781.888, :resident_memory=>13955.072}
 			#
-			# Note:
-			# If you need only memory usage of a process, run LinuxStat::ProcessInfo.memory(pid)
-			# If you need only virtual memory for a process, run LinuxStat::ProcessInfo.virtual_memory(pid)
-			# If you need only resident memory of a process, run LinuxStat::ProcessInfo.resident_memory(pid)
+			# * Note:
+			# 1. If you need only memory usage of a process, run LinuxStat::ProcessInfo.memory(pid)
+			# 2. If you need only virtual memory for a process, run LinuxStat::ProcessInfo.virtual_memory(pid)
+			# 3. If you need only resident memory of a process, run LinuxStat::ProcessInfo.resident_memory(pid)
 			#
 			# This method opens opens multiple files.
+			#
 			# But if you need all of the info, then running this method once is efficient.
 			#
 			# If the info isn't available it will return an empty Hash.
 			def mem_stat(pid = $$)
-				stat_file = "/proc/#{pid}/stat".freeze
-				status_file = "/proc/#{pid}/status".freeze
-
-				stat = if File.readable?(stat_file)
-					IO.read(stat_file).split
-				else
-					[]
-				end
-
-				status = if File.readable?(status_file)
-					IO.readlines(status_file)
-				else
-					[]
-				end
+				statm = "/proc/#{pid}/statm".freeze
+				return {} unless File.readable?(statm)
 
-				_rss_anon = status.find { |x| x.start_with?('RssAnon') }
-				rss_anon = _rss_anon ? _rss_anon.split[1].to_i : nil
+				data = IO.read(statm).split
 
-				_virtual_memory = stat[22]
-				vm = _virtual_memory ? _virtual_memory.to_i.fdiv(1024).to_i : nil
-
-				_vm_rss = status.find { |x| x.start_with?('VmRSS') }
-				vm_rss = _vm_rss ? _vm_rss.split[1].to_i : nil
+				_rss_anon = (data[1] && data[2]) ? data[1].to_i.-(data[2].to_i).*(pagesize).fdiv(1000) : nil
+				_virtual_memory = data[0] ? data[0].to_i*(pagesize).fdiv(1000) : nil
+				_resident_memory = data[1] ? data[1].to_i.*(pagesize).fdiv(1000) : nil
 
 				{
-					memory: rss_anon,
-					virtual_memory: vm,
-					resident_memory: vm_rss
+					memory: _rss_anon,
+					virtual_memory: _virtual_memory,
+					resident_memory: _resident_memory
 				}
 			end
 
-			# memory(pid = $$)
+			##
+			# = memory(pid = $$)
+			#
 			# Where pid is the process ID.
+			#
 			# By default it is the id of the current process ($$)
 			#
 			# It retuns the memory of the process.
-			# The value is in Kilobytes.
-			# The output is an Integer. For example, a sample output:
-			#    8664
+			# The value is in kilobytes.
+			#
+			# The output is an Integer. For example:
+			#    LinuxStat::ProcessInfo.memory
+			#
+			#    8523.776
 			#
 			# If the info isn't available it will return nil.
 			def memory(pid = $$)
-				file = "/proc/#{pid}/status".freeze
+				file = "/proc/#{pid}/statm".freeze
 				return nil unless File.readable?(file)
 
-				_rss_anon = IO.readlines(file).find { |x| x.start_with?('RssAnon') }
-				_rss_anon ? _rss_anon.split[1].to_i : nil
+				data = IO.read(file).split
+				(data[1] && data[2]) ? data[1].to_i.-(data[2].to_i).*(pagesize).fdiv(1000) : nil
 			end
 
-			# virtual_memory(pid = $$)
+			##
+			# = virtual_memory(pid = $$)
+			#
 			# Where pid is the process ID.
+			#
 			# By default it is the id of the current process ($$)
 			#
 			# It retuns the virtual memory for the process.
-			# The value is in Kilobytes.
-			# The output is an Integer. For example, a sample output:
-			#    78376
+			#
+			# The value is in kilobytes.
+			#
+			# The output is an Integer. For example:
+			#    LinuxStat::ProcessInfo.virtual_memory
+			#
+			#    79781.888
 			#
 			# If the info isn't available it will return nil.
 			def virtual_memory(pid = $$)
-				file = "/proc/#{pid}/stat".freeze
+				file = "/proc/#{pid}/statm".freeze
 				return nil unless File.readable?(file)
 
-				_virtual_memory = IO.read(file).split[22]
-				_virtual_memory ? _virtual_memory.to_i.fdiv(1024).to_i : nil
+				_virtual_memory = IO.read(file).split[0]
+				_virtual_memory ? _virtual_memory.to_i.*(pagesize).fdiv(1000) : nil
 			end
 
-			# resident_memory(pid = $$)
+			##
+			# = resident_memory(pid = $$)
+			#
 			# Where pid is the process ID.
+			#
 			# By default it is the id of the current process ($$)
 			#
 			# It retuns the resident memory for the process.
-			# The value is in Kilobytes.
-			# The output is an Integer. For example, a sample output:
-			#    14012
+			#
+			# The value is in kilobytes.
+			#
+			# The output is an Integer. For example:
+			#    LinuxStat::ProcessInfo.cpu_stat
+			#
+			#    => 13996.032
 			#
 			# If the info isn't available it will return nil.
 			def resident_memory(pid = $$)
-				file = "/proc/#{pid}/status".freeze
+				file = "/proc/#{pid}/statm".freeze
 				return nil unless File.readable?(file)
 
-				_vm_rss = IO.readlines(file)
-					.find { |x| x.start_with?('VmRSS') }
-
-				_vm_rss ? _vm_rss.split[1].to_i : nil
+				_vm_rss = IO.read(file).split[1]
+				_vm_rss ? _vm_rss.to_i.*(pagesize).fdiv(1000) : nil
 			end
 
-			# cpu_stat(pid: $$, sleep: 0.05)
+			##
+			# = cpu_stat(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck)
+			#
 			# Where pid is the process ID and sleep time is the interval between measurements.
-			# By default it is the id of the current process ($$), and sleep is 0.05
 			#
-			# Note 1:
-			# Do note that the sleep time can slow down your application.
-			# And it's only needed for the cpu usage calculation.
+			# By default it is the id of the current process ($$), and sleep is LinuxStat::Sysconf.sc_clk_tck
+			#
+			# The smallest amount of available sleep time is 1.0 / LinuxStat::Sysconf.sc_clk_tck.
+			#
+			# * Note 1:
+			# 1. Do note that the sleep time can slow down your application.
+			# 2. And it's only needed for the cpu usage calculation.
 			#
 			# It retuns the CPU usage, threads, and the last executed CPU in Hash.
+			#
 			# For example:
-			#    {:cpu_usage=>0.0, :threads=>1, :last_executed_cpu=>1}
+			#    LinuxStat::ProcessInfo.cpu_stat
+			#
+			#    => {:cpu_usage=>0.0, :threads=>1, :last_executed_cpu=>1}
 			#
 			# But if the info isn't available, it will return an empty Hash.
 			#
-			# The :cpu_usage is in percentage. It's also divided with the number
-			# of CPU. :cpu_usage for example, will return 25.0 if the CPU count
+			# The :cpu_usage is in percentage.
+			# It's also divided with the number of CPU.
+			#
+			# :cpu_usage for example, will return 25.0 if the CPU count
 			# is 4, and the process is using 100% of a thread / core.
-			# A value of 100.0 indicates it is using 100% processing power.
+			#
+			# A value of 100.0 indicates it is using 100% processing power available to the system.
 			#
 			# The :threads returns the number of threads for the process.
 			# The value is a Integer.
 			#
-			# Note 2:
-			# If you just need the CPU usage run LinuxStat::ProcessInfo.cpu_usage(pid = $$)
-			# If you just need the threads run LinuxStat::ProcessInfo.threads(pid = $$)
-			# If you just need the last executed CPU run LinuxStat::ProcessInfo.last_executed_cpu(pid = $$)
-			# Running this method is slower and it opens multiple files at once
+			# * Note 2:
+			# 1. If you just need the CPU usage run LinuxStat::ProcessInfo.cpu_usage(pid = $$)
+			# 2. If you just need the threads run LinuxStat::ProcessInfo.threads(pid = $$)
+			# 3. If you just need the last executed CPU run LinuxStat::ProcessInfo.last_executed_cpu(pid = $$)
+			# 4. Running this method is slower and it opens multiple files at once
 			#
 			# Only use this method if you need all of the data at once, in such case, it's more efficient to use this method.
 			#
-			# The :last_executed_cpu also returns an Integer indicating
-			# the last executed cpu of the process.
-			def cpu_stat(pid: $$, sleep: 0.05)
+			# The :last_executed_cpu also returns an Integer indicating the last executed cpu of the process.
+			def cpu_stat(pid: $$, sleep: ticks_to_ms)
 				file = "/proc/#{pid}/stat"
 				return {} unless File.readable?(file)
 
@@ -236,19 +276,29 @@ module LinuxStat
 				}
 			end
 
-			# cpu_usage(pid: $$, sleep: 0.05)
+			##
+			# = cpu_usage(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck)
+			#
 			# Where pid is the process ID and sleep time is the interval between measurements.
-			# By default it is the id of the current process ($$), and sleep is 0.05
+			#
+			# By default it is the id of the current process ($$), and sleep is 1.0 / LinuxStat::Sysconf.sc_clk_tck
+			#
+			# The smallest amount of available sleep time is LinuxStat::Sysconf.sc_clk_tck.
 			#
 			# It retuns the CPU usage in Float.
+			#
 			# For example:
-			#    10.0
-			# A value of 100.0 indicates it is using 100% processing power.
+			#
+			#    LinuxStat::ProcessInfo.cpu_usage
+			#
+			#    => 10.0
+			#
+			# A value of 100.0 indicates it is using 100% processing power available to the system.
 			#
 			# But if the info isn't available, it will return nil.
 			#
 			# This method is more efficient than running LinuxStat::ProcessInfo.cpu_stat()
-			def cpu_usage(pid: $$, sleep: 0.05)
+			def cpu_usage(pid: $$, sleep: ticks_to_ms)
 				file = "/proc/#{pid}/stat"
 				return nil unless File.readable?(file)
 
@@ -274,13 +324,20 @@ module LinuxStat
 				totald.-(idle2 - idle1).fdiv(totald).*(100).round(2).abs./(LinuxStat::CPU.count)
 			end
 
-			# threads(pid = $$)
+			##
+			# = threads(pid = $$)
+			#
 			# Where pid is the process ID.
+			#
 			# By default it is the id of the current process ($$)
 			#
 			# It retuns the threads for the current process in Integer.
+			#
 			# For example:
-			#    1
+			#    LinuxStat::ProcessInfo.threads
+			#
+			#    => 2
+			#
 			# But if the info isn't available, it will return nil.
 			#
 			# This method is way more efficient than running LinuxStat::ProcessInfo.cpu_stat()
@@ -288,16 +345,24 @@ module LinuxStat
 				file = "/proc/#{pid}/stat".freeze
 				return nil unless File.readable?(file)
 
-				IO.read(file).split[19].to_i
+				data = IO.read(file).split[19]
+				data ? data.to_i : nil
 			end
 
-			# last_executed_cpu(pid = $$)
+			##
+			# = last_executed_cpu(pid = $$)
+			#
 			# Where pid is the process ID.
+			#
 			# By default it is the id of the current process ($$)
 			#
 			# It retuns the last executed CPU in Integer.
+			#
 			# For example:
-			#    2
+			#    LinuxStat::ProcessInfo.last_executed_cpu
+			#
+			#    => 2
+			#
 			# But if the info isn't available, it will return nil.
 			#
 			# This method is way more efficient than running LinuxStat::ProcessInfo.cpu_stat()
@@ -305,17 +370,84 @@ module LinuxStat
 				file = "/proc/#{pid}/stat".freeze
 				return nil unless File.readable?(file)
 
-				IO.read("/proc/#{pid}/stat".freeze).split[38].to_i
+				IO.read(file).split[38].to_i
 			end
 
-			# def owned_by
+			##
+			# = uid(pid = $$)
+			#
+			# returns the UIDs of the process as an Array of Integers.
+			#
+			# If the info isn't available it returns an empty Array.
+			def uid(pid = $$)
+				file = "/proc/#{pid}/status".freeze
+				return nil unless File.readable?(file)
 
-			# end
+				data = IO.readlines(file.freeze).find { |x|
+					x[/Uid.*\d*/]
+				}.to_s.split.drop(1)
+
+				{
+					real: data[0].to_i,
+					effective: data[1].to_i,
+					saved_set: data[2].to_i,
+					filesystem_uid: data[3].to_i
+				}
+			end
+
+			##
+			# = gid(pid = $$)
+			#
+			# returns the GIDs of the process as an Hash containing the following data:
+			#
+			#    :real, :effective, :saved_set, :filesystem_uid
+			#
+			# If the info isn't available it returns an empty Hash.
+			def gid(pid = $$)
+				file = "/proc/#{pid}/status".freeze
+				return nil unless File.readable?(file)
+
+				data = IO.readlines(file.freeze).find { |x|
+					x[/Gid.*\d*/]
+				}.split.drop(1)
+
+				{
+					real: data[0].to_i,
+					effective: data[1].to_i,
+					saved_set: data[2].to_i,
+					filesystem_uid: data[3].to_i
+				}
+			end
+
+			##
+			# = owner(pid = $$)
+			#
+			# Returns the owner of the process
+			# But if the status is not available, it will return an empty frozen String.
+			def owner(pid = $$)
+				file = "/proc/#{pid}/status".freeze
+				return ''.freeze unless File.readable?(file)
+
+				gid = IO.readlines(file.freeze).find { |x|
+					x[/Gid.*\d*/]
+				}.split.drop(1)[2].to_i
+
+				LinuxStat::User.username_by_gid(gid)
+			end
 
 			private
 			def get_ticks
 				@@ticks ||= Sysconf.sc_clk_tck
 			end
+
+			# Just to avoid multiple calculations!...
+			def ticks_to_ms
+				@@ms ||= 1.0 / get_ticks
+			end
+
+			def pagesize
+				@@pagesize ||= LinuxStat::Sysconf.pagesize
+			end
 		end
 	end
 end