linux_stat 0.7.0 → 0.9.0

data/lib/linux_stat/filesystem.rb

@@ -2,7 +2,7 @@ module LinuxStat
 	module Filesystem
 		class << self
 			##
-			# = stat(fs = '/')
+			# = stat(fs = '.')
 			#
 			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
 			#
@@ -16,7 +16,7 @@ module LinuxStat
 			#    {:total=>119981191168, :free=>43155574784, :used=>76825616384, :available=>43155574784}
 			#
 			# If the stat can't be acquired, this method will return an empty Hash.
-			def stat(fs = ?/.freeze)
+			def stat(fs = ?..freeze)
 				s = stat_raw(fs)
 				return {} if s.empty?
 				s.default = 0
@@ -29,14 +29,14 @@ module LinuxStat
 			end
 
 			##
-			# = total(fs = '/')
+			# = total(fs = '.')
 			#
 			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
 			#
 			# It returns the total size of a given disk in bytes.
 			#
 			# If the stat can't be acquired, this method will return nil.
-			def total(fs = ?/.freeze)
+			def total(fs = ?..freeze)
 				s = stat_raw(fs)
 				return nil if s.empty?
 				s.default = 0
@@ -44,7 +44,7 @@ module LinuxStat
 			end
 
 			##
-			# = free(fs = '/')
+			# = free(fs = '.')
 			#
 			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
 			#
@@ -55,7 +55,7 @@ module LinuxStat
 			# Free returns the size of free blocks.
 			#
 			# If the stat can't be acquired, this method will return an empty Hash.
-			def free(fs = ?/.freeze)
+			def free(fs = ?..freeze)
 				s = stat_raw(fs)
 				return nil if s.empty?
 				s.default = 0
@@ -63,14 +63,14 @@ module LinuxStat
 			end
 
 			##
-			# = used(fs = '/')
+			# = used(fs = '.')
 			#
 			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
 			#
 			# It returns the used space of a given disk in bytes.
 			#
 			# If the stat can't be acquired, this method will return nil.
-			def used(fs = ?/.freeze)
+			def used(fs = ?..freeze)
 				s = stat_raw(fs)
 				return nil if s.empty?
 				s.default = 0
@@ -78,7 +78,7 @@ module LinuxStat
 			end
 
 			##
-			# = available(fs = '/')
+			# = available(fs = '.')
 			#
 			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
 			#
@@ -89,7 +89,7 @@ module LinuxStat
 			# Available returns the size of free blocks for unpriviledged users.
 			#
 			# If the stat can't be acquired, this method will return an empty Hash.
-			def available(fs = ?/.freeze)
+			def available(fs = ?..freeze)
 				s = stat_raw(fs)
 				return nil if s.empty?
 				s.default = 0
@@ -97,7 +97,7 @@ module LinuxStat
 			end
 
 			##
-			# = stat_raw(fs = '/')
+			# = stat_raw(fs = '.')
 			#
 			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
 			#
@@ -105,7 +105,7 @@ module LinuxStat
 			#    {:block_size=>4096, :fragment_size=>4096, :blocks=>29292283, :block_free=>10535967, :block_avail_unpriv=>10535967, :inodes=>58612160, :free_inodes=>56718550, :filesystem_id=>2050, :mount_flags=>1024, :max_filename_length=>255}
 			#
 			# If the stat can't be acquired, this method will return an empty Hash.
-			def stat_raw(fs = ?/.freeze)
+			def stat_raw(fs = ?..freeze)
 				LinuxStat::FS.stat(fs)
 			end
 		end

data/lib/linux_stat/kernel.rb

@@ -185,7 +185,7 @@ module LinuxStat
 
 			private
 			def splitted
-				@@string_splitted ||= string.split
+				@@string_splitted ||= string.split.freeze
 			end
 		end
 	end

data/lib/linux_stat/os.rb

@@ -121,7 +121,7 @@ module LinuxStat
 					hour: h,
 					minute: m,
 					second: s
-				}
+				}.freeze
 			end
 
 			private
@@ -143,7 +143,7 @@ module LinuxStat
 			end
 
 			def uptime_readable?
-				@@uptime_readable = File.readable?('/proc/uptime')
+				@@uptime_readable ||= File.readable?('/proc/uptime')
 			end
 		end
 	end

data/lib/linux_stat/prettify_bytes.rb

@@ -100,10 +100,7 @@ module LinuxStat
 
 			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
+				sprintf("%.#{mantissa_length}f".freeze, n)
 			end
 		end
 	end

data/lib/linux_stat/process.rb

@@ -6,7 +6,7 @@ module LinuxStat
 			#
 			# The return type is an Array of Integers.
 			def list
-				Dir['/proc/*'].select! { |x|
+				Dir['/proc/*'].select { |x|
 					pid = File.split(x)[1]
 					pid.to_i.to_s == pid
 				}.map! { |x| File.split(x)[-1].to_i }

data/lib/linux_stat/process_info.rb

@@ -203,13 +203,13 @@ module LinuxStat
 			end
 
 			##
-			# = cpu_stat(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck)
+			# = cpu_stat(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5)
 			#
 			# 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 LinuxStat::Sysconf.sc_clk_tck
 			#
-			# The smallest amount of available sleep time is 1.0 / LinuxStat::Sysconf.sc_clk_tck.
+			# The smallest amount of available sleep time is 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5.
 			#
 			# * Note 1:
 			# 1. Do note that the sleep time can slow down your application.
@@ -244,20 +244,22 @@ module LinuxStat
 			# 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: ticks_to_ms)
+			def cpu_stat(pid: $$, sleep: ticks_to_ms_t5)
 				file = "/proc/#{pid}/stat"
-				return {} unless File.readable?(file)
-
 				ticks = get_ticks
 
+				return {} unless File.readable?(file)
 				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)
+
+				return {} unless File.readable?(file)
 				stat = IO.read(file).split
 
 				utime2, stime2, starttime2 = stat.values_at(13, 14, 21).map(&:to_f)
@@ -267,25 +269,25 @@ module LinuxStat
 				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_u = totald.-(idle2 - idle1).fdiv(totald).abs.*(100)./(cpu_count)
 
 				{
-					cpu_usage: cpu,
+					cpu_usage: cpu_u > 100 ? 100.0 : cpu_u.round(2),
 					threads: stat[19].to_i,
 					last_executed_cpu: stat[38].to_i
 				}
 			end
 
 			##
-			# = cpu_usage(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck)
+			# = cpu_usage(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5)
 			#
 			# 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 1.0 / LinuxStat::Sysconf.sc_clk_tck
+			# By default it is the id of the current process ($$), and sleep is 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5
 			#
 			# The smallest amount of available sleep time is LinuxStat::Sysconf.sc_clk_tck.
 			#
-			# It retuns the CPU usage in Float.
+			# It retuns the CPU usage as Float.
 			#
 			# For example:
 			#
@@ -293,19 +295,75 @@ module LinuxStat
 			#
 			#    => 10.0
 			#
+			# 10.0 means it's using 10% of the total processing power of the system.
+			#
+			# The value is divided with the configured number of CPU and not online CPU.
+			#
 			# 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: ticks_to_ms)
+			def cpu_usage(pid: $$, sleep: ticks_to_ms_t5)
 				file = "/proc/#{pid}/stat"
+				ticks = get_ticks
+
+				return nil unless File.readable?(file)
+				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)
+
 				return nil unless File.readable?(file)
+				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)
 
+				u = totald.-(idle2 - idle1).fdiv(totald).abs.*(100)./(cpu_count)
+				u > 100 ? 100.0 : u.round(2)
+			end
+
+			##
+			# = thread_usage(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5)
+			#
+			# 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 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5
+			#
+			# The smallest amount of available sleep time is LinuxStat::Sysconf.sc_clk_tck.
+			#
+			# It retuns the per core CPU usage as Float.
+			#
+			# For example:
+			#
+			#    LinuxStat::ProcessInfo.core_usage
+			#
+			#    => 200.0
+			#
+			# A value of 100.0 indicates it is using 100% processing power of a core.
+			#
+			# The value could be 0 to (100 * the number of CPU threads (including hyperthreading) in the system)
+			#
+			# But if the info isn't available, it will return nil.
+			def thread_usage(pid: $$, sleep: ticks_to_ms_t5)
+				file = "/proc/#{pid}/stat"
 				ticks = get_ticks
 
+				return nil unless File.readable?(file)
 				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
@@ -313,15 +371,21 @@ module LinuxStat
 
 				sleep(sleep)
 
+				return nil unless File.readable?(file)
 				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)
+
+				u = totald.-(idle2 - idle1).fdiv(totald).abs.*(100)
+
+				cpu_count_t100 = cpu_count * 100
+				u > cpu_count_t100 ? cpu_count_t100 : u.round(2)
 			end
 
 			##
@@ -435,6 +499,32 @@ module LinuxStat
 				LinuxStat::User.username_by_gid(gid)
 			end
 
+			##
+			# = start_time_epoch(pid = $$)
+			#
+			# Returns the epoch time (as Integer) the process was started.
+			#
+			# For example:
+			#    LinuxStat::ProcessInfo.start_time_epoch 526
+			#
+			#    => 1608097744
+			#
+			# If the info isn't available or the argument passed doesn't exist as a process ID, it will return nil.
+			def start_time_epoch(pid = $$)
+				stat_file = "/proc/#{pid}/stat".freeze
+				uptime = "/proc/uptime".freeze
+
+				@@u_readable ||= File.readable?(uptime)
+				return nil unless @@u_readable && File.readable?(stat_file)
+
+				u = IO.foreach(uptime, ' '.freeze).next.to_f
+				st = (IO.foreach(stat_file, ' '.freeze).first(22)[-1].to_f / get_ticks)
+
+				# Getting two Time objects and dealing with floating point numbers
+				# Just to make sure the time goes monotonically
+				Time.now.-(u - st).to_i
+			end
+
 			##
 			# = start_time(pid = $$)
 			#
@@ -443,7 +533,7 @@ module LinuxStat
 			# For example:
 			#    LinuxStat::ProcessInfo.start_time 14183
 			#
-			#    => 2020-12-16 13:31:43.559061275 +0000
+			#    => 2020-12-16 13:31:43 +0000
 			#
 			# If the info isn't available or the argument passed doesn't exist as a process ID, it will return nil.
 			#
@@ -452,13 +542,9 @@ module LinuxStat
 			#
 			# Don't trust the timezone returned by the time.
 			def start_time(pid = $$)
-				stat_file = "/proc/#{pid}/stat".freeze
-				uptime = "/proc/uptime".freeze
-
-				@@u_readable ||= File.readable?(uptime)
-				return nil unless @@u_readable && File.readable?(stat_file)
-
-				Time.now.-(IO.foreach(uptime, ' '.freeze).next.to_i - (IO.read(stat_file).split[21].to_i / get_ticks))
+				# Getting two Time objects and dealing with floating point numbers
+				# Just to make sure the time goes monotonically
+				Time.at(start_time_epoch(pid))
 			end
 
 			##
@@ -469,7 +555,9 @@ module LinuxStat
 			# For example:
 			#    LinuxStat::ProcessInfo.running_time 14183
 			#
-			#    => 1947.619999999999
+			#    => 1947.61
+			#
+			# It always rounds the float number upto 2 decimal places
 			#
 			# If the info isn't available or the argument passed doesn't exist as a process ID, it will return nil.
 			def running_time(pid = $$)
@@ -479,7 +567,8 @@ module LinuxStat
 				@@u_readable ||= File.readable?(uptime)
 				return nil unless @@u_readable && File.readable?(stat_file)
 
-				IO.foreach(uptime, ' '.freeze).next.to_f - (IO.read(stat_file).split[21].to_i / get_ticks)
+				IO.foreach(uptime, ' '.freeze).next.to_f
+					.-(IO.read(stat_file).split[21].to_f / get_ticks).round(2)
 			end
 
 			##
@@ -522,19 +611,57 @@ module LinuxStat
 				IO.foreach(file, ' ').first(19)[-1].to_i
 			end
 
+			##
+			# = nproc(pid = $$)
+			# Returns the cpu allocated to the process.
+			#
+			# The output value is an Integer.
+			#
+			# For example:
+			#    $ taskset -c 0 irb
+			#
+			#    irb(main):001:0> require 'linux_stat'
+			#
+			#    => true
+			#
+			#    irb(main):002:0> LinuxStat::ProcessInfo.nproc
+			#
+			#    => 1
+			#
+			#    irb(main):003:0> LinuxStat::ProcessInfo.nproc 11562
+			#
+			#    => 3
+			#
+			#    irb(main):004:0> LinuxStat::ProcessInfo.nproc 12513
+			#
+			#    => 4
+			#
+			# If the info isn't available or the argument passed doesn't exist as a process ID, it will return nil.
+			def nproc(pid = $$)
+				LinuxStat::Nproc.count_cpu_for_pid(pid)
+			end
+
+			alias count_cpu nproc
+
 			private
 			def get_ticks
 				@@ticks ||= Sysconf.sc_clk_tck
 			end
 
 			# Just to avoid multiple calculations!...
-			def ticks_to_ms
-				@@ms ||= 1.0 / get_ticks
+			# ticks to ms * 5
+			# If ticks is 100, it will return 0.05
+			def ticks_to_ms_t5
+				@@ms_t5 ||= 1.0 / get_ticks * 5
 			end
 
 			def pagesize
 				@@pagesize ||= LinuxStat::Sysconf.pagesize
 			end
+
+			def cpu_count
+				@@nprocessors_conf ||= LinuxStat::CPU.count
+			end
 		end
 	end
 end