linux_stat 0.3.1 → 0.5.1

data/lib/linux_stat/kernel.rb

@@ -3,7 +3,7 @@ module LinuxStat
 		class << self
 			# Returns the Linux Kernel version.
 			# If the information isn't available, it will return a frozen empty string.
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def version
 				return ''.freeze if string.empty?
 				@@version ||= splitted[2]
@@ -11,7 +11,7 @@ module LinuxStat
 
 			# Returns the name of the user who built the kernel using KBUILD_FLAGS.
 			# If the information isn't available, it will return a frozen empty string.
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def build_user
 				@@build_user ||= string.split(/(\(.+\))/).each(&:strip!)
 					.reject(&:empty?).find { |x| x[/^\(.+\)$/] }.to_s
@@ -20,7 +20,7 @@ module LinuxStat
 
 			# Returns the compiler used to compile the Linux Kernel.
 			# If the information isn't available, it will return a frozen empty string.
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def compiler
 				return ''.freeze if string.empty?
 
@@ -39,7 +39,7 @@ module LinuxStat
 
 			# Returns the compiler version used to compile the Linux Kernel.
 			# If the information isn't available, it will return a frozen empty string.
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def compiler_version
 				@@compiler_version ||= string.split(/(\(.+?\))/).each(&:strip!)
 					.reject(&:empty?)[2..4].to_a
@@ -62,7 +62,7 @@ module LinuxStat
 			# You have to use regexp yourself to get the proper zone.
 			# Use LinuxStat::Kernel.build_date_string to get the original string if you need that.
 			#
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			# The output is also cached  (memoized) ; as changing the value in runtime is unexpected.
 			def build_date
 				return nil if splitted.empty?
 
@@ -107,7 +107,7 @@ module LinuxStat
 			# You have to use regexp yourself to get the proper zone.
 			# Use LinuxStat::Kernel.build_date_string to get the original string if you need that.
 			#
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def build_date_string
 				return nil if splitted.empty?
 
@@ -139,6 +139,16 @@ module LinuxStat
 				@@string ||= File.readable?('/proc/version') ? IO.read('/proc/version', 1024).tap(&:strip!) : ''
 			end
 
+			# Returns the sc_clk_tck or the same output from command `getconf CLK_TCK`.
+			# Also, clk_tck is an alias of this method.
+			# The output is also cached ; as changing the value in runtime is unexpected.
+			def ticks
+				@@tick ||= LinuxStat::Sysconf.sc_clk_tck
+			end
+
+			alias release version
+			alias clk_tck ticks
+
 			private
 			def splitted
 				@@string_splitted ||= string.split

data/lib/linux_stat/memory.rb

@@ -2,9 +2,10 @@ module LinuxStat
 	module Memory
 		class << self
 			# Returns the memory details reported by /proc/meminfo. In this format:
-			# {:total=>3836264, :used=>3097952, :available=>738312, :percent_used=>80.75, :percent_available=>19.25}
+			#    {:total=>3836264, :used=>3097952, :available=>738312, :percent_used=>80.75, :percent_available=>19.25}
+			#
+			# The values are in Kilobyte.
 			#
-			# The value is in Kilobyte.
 			# If the statistics is not available, it will return an empty Hash.
 			def stat
 				return {} unless meminfo?
@@ -31,6 +32,7 @@ module LinuxStat
 
 			# Returns the total memory details reported by /proc/meminfo.
 			# The value is in Kilobyte.
+			#
 			# It retuns an Integer but if the info is not available, it will return nil.
 			def total
 				return nil unless meminfo?
@@ -39,6 +41,7 @@ module LinuxStat
 
 			# Returns the total memory details reported by /proc/meminfo.
 			# The value is in Kilobyte.
+			#
 			# It retuns an Integer but if the info is not available, it will return nil
 			def available
 				return nil unless meminfo?
@@ -47,6 +50,7 @@ module LinuxStat
 
 			# Returns the amount of memory used reported by /proc/meminfo.
 			# The value is in Kilobyte.
+			#
 			# It retuns an Integer but if the info is not available, it will return nil.
 			def used
 				return nil unless meminfo?
@@ -55,6 +59,7 @@ module LinuxStat
 			end
 
 			# Returns the percentage of memory used reported by /proc/meminfo.
+			#
 			# It retuns an Integer but if the info is not available, it will return nil
 			def percent_used
 				return nil unless meminfo?
@@ -64,6 +69,7 @@ module LinuxStat
 			end
 
 			# Returns the percentage of memory used reported by /proc/meminfo.
+			#
 			# It retuns an Integer but if the info is not available,  it will return nil
 			def percent_available
 				return nil unless meminfo?

data/lib/linux_stat/os.rb

@@ -2,7 +2,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"}
+			#    {: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"}
 			#
 			# If the info isn't available, it will return an empty Hash.
 			#
@@ -11,12 +11,12 @@ module LinuxStat
 			# 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 ; as changing the value in runtime is unexpected
+				# 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"}
+			#    {:LSB_VERSION=>"1.4", :DISTRIB_ID=>"Arch", :DISTRIB_RELEASE=>"rolling", :DISTRIB_DESCRIPTION=>"Arch Linux"}
 			#
 			# If the info isn't available, it will return an empty Hash.
 			#
@@ -25,12 +25,13 @@ module LinuxStat
 			# 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 ; as changing the value in runtime is unexpected
+				# 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.
 			# If none of the info is available, it will return an empty frozen String.
 			def distribution
@@ -51,7 +52,22 @@ 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
+			def machine
+				@@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
+			def nodename
+				@@nodename ||= LinuxStat::Uname.nodename
+			end
+
 			# Reads /etc/hostname and returns the hostname.
+			#
 			# The return type is String.
 			# If the info info isn't available, it will return 'localhost'.
 			def hostname
@@ -62,10 +78,13 @@ module LinuxStat
 				end
 			end
 
-			# Reads ruby configuration and tries to guess if the system is 32 bit or 64 bit.
-			# The return type is Integer.
+			# 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.
 			def bits
-				@@bits ||= if RbConfig::CONFIG['host_cpu'].end_with?('64') || RUBY_PLATFORM[/x86_64/]
+				@@bits ||= if RbConfig::CONFIG['host_cpu'].end_with?('64') || RUBY_PLATFORM.end_with?('64') || machine.end_with?('64')
 					64
 				else
 					32
@@ -73,7 +92,7 @@ module LinuxStat
 			end
 
 			# Reads /proc/uptime and returns the system uptime:
-			# {:hour=>10, :minute=>34, :second=>12.59}
+			#    {:hour=>10, :minute=>34, :second=>12.59}
 			#
 			# If the stat isn't available, an empty hash is returned.
 			def uptime

data/lib/linux_stat/process_info.rb

@@ -0,0 +1,321 @@
+module LinuxStat
+	module ProcessInfo
+		class << self
+			# 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:
+			#    {:read_bytes=>0, :write_bytes=>0}
+			#
+			# The output is only based on the total disk IO the process has done.
+			#
+			# If the info isn't available it will return an empty Hash.
+			def total_io(pid = $$)
+				return {} unless File.readable?("/proc/#{pid}/io".freeze)
+				out = {}
+
+				IO.readlines("/proc/#{pid}/io".freeze).each { |x|
+					x.strip!
+
+					if x[/^(read|write)_bytes:\s*\d*$/]
+						splitted = x.split
+						out.merge!(splitted[0].split(?:)[0].to_sym => splitted[-1].to_i)
+					end
+				}
+
+				out
+			end
+
+			# 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:
+			#    "ruby -r linux_stat -e p LinuxStat::ProcessInfo.cmdline"
+			#
+			# If the info isn't available it will return an empty frozen String.
+			def cmdline(pid = $$)
+				file = "/proc/#{pid}/cmdline".freeze
+				return ''.freeze unless File.readable?(file)
+
+				_cmdline = IO.read(file)
+				_cmdline.gsub!(?\u0000, ?\s)
+				_cmdline.tap(&:strip!)
+			end
+
+			# 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:
+			#    "ruby"
+			#
+			# If the info isn't available it will return an empty frozen String.
+			def command_name(pid = $$)
+				# Do note that the /proc/ppid/comm may not contain the full name
+				file = "/proc/#{pid}/cmdline".freeze
+				return ''.freeze unless File.readable?(file)
+
+				_cmdline = IO.read(file)
+				_cmdline.gsub!(?\u0000, ?\s)
+				File.split(_cmdline.tap(&:strip!).split[0])[-1]
+			end
+
+			# 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}
+			#
+			# 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)
+			#
+			# 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
+
+				_rss_anon = status.find { |x| x.start_with?('RssAnon') }
+				rss_anon = _rss_anon ? _rss_anon.split[1].to_i : nil
+
+				_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
+
+				{
+					memory: rss_anon,
+					virtual_memory: vm,
+					resident_memory: vm_rss
+				}
+			end
+
+			# 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
+			#
+			# If the info isn't available it will return nil.
+			def memory(pid = $$)
+				file = "/proc/#{pid}/status".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
+			end
+
+			# 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
+			#
+			# If the info isn't available it will return nil.
+			def virtual_memory(pid = $$)
+				file = "/proc/#{pid}/stat".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
+			end
+
+			# 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
+			#
+			# If the info isn't available it will return nil.
+			def resident_memory(pid = $$)
+				file = "/proc/#{pid}/status".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
+			end
+
+			# cpu_stat(pid: $$, sleep: 0.05)
+			# 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.
+			#
+			# 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}
+			#
+			# 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
+			# is 4, and the process is using 100% of a thread / core.
+			# A value of 100.0 indicates it is using 100% processing power.
+			#
+			# 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
+			#
+			# 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)
+				file = "/proc/#{pid}/stat"
+				return {} unless File.readable?(file)
+
+				ticks = get_ticks
+
+				utime, stime, starttime = IO.read(file)
+					.split.values_at(13, 14, 21).map(&:to_f)
+				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
+
+				total_time = utime + stime
+				idle1 = uptime - starttime - total_time
+
+				sleep(sleep)
+				stat = IO.read(file).split
+
+				utime2, stime2, starttime2 = stat.values_at(13, 14, 21).map(&:to_f)
+				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
+
+				total_time2 = utime2 + stime2
+				idle2 = uptime - starttime2 - total_time2
+
+				totald = idle2.+(total_time2).-(idle1 + total_time)
+				cpu = totald.-(idle2 - idle1).fdiv(totald).*(100).round(2).abs./(LinuxStat::CPU.count)
+
+				{
+					cpu_usage: cpu,
+					threads: stat[19].to_i,
+					last_executed_cpu: stat[38].to_i
+				}
+			end
+
+			# cpu_usage(pid: $$, sleep: 0.05)
+			# 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
+			#
+			# It retuns the CPU usage in Float.
+			# For example:
+			#    10.0
+			# A value of 100.0 indicates it is using 100% processing power.
+			#
+			# 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)
+				file = "/proc/#{pid}/stat"
+				return nil unless File.readable?(file)
+
+				ticks = get_ticks
+
+				utime, stime, starttime = IO.read(file)
+					.split.values_at(13, 14, 21).map(&:to_f)
+				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
+
+				total_time = utime + stime
+				idle1 = uptime - starttime - total_time
+
+				sleep(sleep)
+
+				utime2, stime2, starttime2 = IO.read(file)
+					.split.values_at(13, 14, 21).map(&:to_f)
+				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
+
+				total_time2 = utime2 + stime2
+				idle2 = uptime - starttime2 - total_time2
+
+				totald = idle2.+(total_time2).-(idle1 + total_time)
+				totald.-(idle2 - idle1).fdiv(totald).*(100).round(2).abs./(LinuxStat::CPU.count)
+			end
+
+			# 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
+			# But if the info isn't available, it will return nil.
+			#
+			# This method is way more efficient than running LinuxStat::ProcessInfo.cpu_stat()
+			def threads(pid = $$)
+				file = "/proc/#{pid}/stat".freeze
+				return nil unless File.readable?(file)
+
+				IO.read(file).split[19].to_i
+			end
+
+			# 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
+			# But if the info isn't available, it will return nil.
+			#
+			# This method is way more efficient than running LinuxStat::ProcessInfo.cpu_stat()
+			def last_executed_cpu(pid = $$)
+				file = "/proc/#{pid}/stat".freeze
+				return nil unless File.readable?(file)
+
+				IO.read("/proc/#{pid}/stat".freeze).split[38].to_i
+			end
+
+			# def owned_by
+
+			# end
+
+			private
+			def get_ticks
+				@@ticks ||= Sysconf.sc_clk_tck
+			end
+		end
+	end
+end