linux_stat 0.6.4 → 0.7.5

data/exe/linuxstat.rb

@@ -7,6 +7,46 @@ rescue LoadError
 	abort "The Gem needs to be installed before this test can be run!"
 end
 
+# Gradient colour to strings
+class String
+	def colourize(colour = 1, flip: false)
+		colours, line_length = [], -1
+		temp = ''
+
+		each_line do |c|
+			n, i = c.length, -1
+
+			if line_length != n
+				step, line_length = 255.0./(n), n
+				colours.clear
+
+				while (i += 1) < n
+					l = i.*(step)
+					colours.<<(
+						case colour
+							when 0 then [ l.*(2).to_i.clamp(0, 255), l.to_i.clamp(0, 255), 255.-(l).to_i.clamp(0, 255) ]
+							when 1 then [ 255, 255.-(l).to_i.clamp(0, 255), l.to_i.clamp(0, 255) ]
+							when 2 then [ l.to_i.clamp(0, 255), 255.-(l).to_i.clamp(0, 255), l.to_i.clamp(0, 255) ]
+							when 3 then [ l.*(2).to_i.clamp(0, 255), 255.-(l).to_i.clamp(0, 255), 100.+(l / 2).to_i.clamp(0, 255) ]
+							when 4 then [ 30, 255.-(l / 2).to_i.clamp(0, 255), 110.+(l / 2).to_i.clamp(0, 255) ]
+							when 5 then [ 255.-(l * 2).to_i.clamp(0, 255), l.to_i.clamp(0, 255), 200 ]
+							when 6 then [ 50.+(255 - l).to_i.clamp(0, 255), 255.-(l / 2).to_i.clamp(0, 255), (l * 2).to_i.clamp(0, 255) ]
+							else [ l.*(2).to_i.clamp(0, 255), 255.-(l).to_i.clamp(0, 255), 100.+(l / 2).to_i.clamp(0, 255) ]
+						end
+					)
+				end
+
+				colours.reverse! if flip
+			end
+
+			i = -1
+			temp.concat "\e[38;2;#{colours[i][0]};#{colours[i][1]};#{colours[i][2]}m#{c[i]}" while (i += 1) < n
+		end
+
+		temp << "\e[0m".freeze
+	end
+end
+
 # Check which conflicting argument (e.g., `-md -html` together) is passed last
 # Always use the last argument
 conflicting, hash = [
@@ -54,7 +94,6 @@ execute.sort.each do |c|
 	next if e.class != Module && e.class != Class
 
 	meths = e.methods(false).sort
-	next if meths.any? { |a| e.method(a).arity > 0 }
 
 	if meths.length > 0
 		if MARKDOWN
@@ -67,20 +106,68 @@ execute.sort.each do |c|
 	end
 
 	meths.each do |meth|
+		arg = nil
+		params = e.method(meth).parameters
+
+		param = ''
+
+		params.each do |p|
+			case p[0]
+				when :opt
+					param << "#{p[1]}, "
+				when :key
+					param << "#{p[1]}:, "
+				when :req
+					param << "#{p[1] || 'arg'}, "
+			end
+		end
+
+		param.delete_suffix!(", ")
+
+		if e.method(meth).arity > 0
+			if c == :PrettifyBytes
+				arg = rand(10 ** 15)
+			elsif c == :FS
+				arg = '/'
+			else
+				next
+			end
+		end
+
+		disp_meth = "#{meth}"
+		disp_meth.concat(arg ? "(#{param} = #{arg.inspect})" : "(#{param})")
+
 		time = Time.now
-		v = e.send(meth)
+		v = arg ? e.send(meth, arg) : e.send(meth)
 		time2 = Time.now
 		time = time2.-(time).*(1_000_000).round(3)
 
 		v = v.inspect
 		dis = v.length > 253 ? v[0..250].strip + '...'.freeze : v
 
+		source = e.singleton_method(meth).source_location.to_a
+		src, src_meth = '', ''
+
+		unless source.empty?
+			src << " File: #{File.split(source[0])[-1]} | Line: #{source[1]}\n"
+			src_meth << " Definition: #{IO.foreach(source[0]).first(source[1])[-1].strip}\n"
+
+			if MARKDOWN || HTML
+				src.prepend('#'.freeze)
+				src_meth.prepend('#'.freeze)
+			else
+				src.prepend(?\u2B23.freeze)
+				src_meth.prepend(?\u2B23.freeze)
+			end
+		end
+
+
 		if MARKDOWN
-			puts "#{e}.#{meth}\n=> #{dis}"
+			puts "#{src}#{src_meth}#{e}.#{disp_meth}\n=> #{dis}"
 		elsif HTML
-			puts "#{e}.#{meth}\n=> #{dis}"
+			puts "#{src}#{src_meth}#{e}.#{disp_meth}\n=> #{dis}"
 		else
-			puts "\e[1;38;2;80;80;255m#{e}.#{meth}\e[0m\n=> #{dis}"
+			puts "\e[1m#{src.colourize}\e[1m#{src_meth.colourize(4)}\e[0m\e[1;38;2;80;80;255m#{e}.#{disp_meth}\e[0m\n=> #{dis}"
 		end
 
 		puts( "(" +

data/ext/fs_stat/fs_stat.c

@@ -3,7 +3,6 @@
 
 #pragma GCC optimize ("O3")
 #pragma clang optimize on
-#pragma once
 
 static VALUE statfs(VALUE obj, VALUE dir) {
 	struct statvfs buf ;

data/ext/sysconf/sysconf.c

@@ -3,7 +3,6 @@
 
 #pragma GCC optimize ("O3")
 #pragma clang optimize on
-#pragma once
 
 static VALUE getTick(VALUE obj) {
 	return INT2FIX(sysconf(_SC_CLK_TCK)) ;

data/ext/utsname/utsname.c

@@ -3,7 +3,6 @@
 
 #pragma GCC optimize ("O3")
 #pragma clang optimize on
-#pragma once
 
 static struct utsname buf ;
 static short status ;

data/lib/linux_stat/cpu.rb

@@ -2,7 +2,7 @@ module LinuxStat
 	module CPU
 		class << self
 			##
-			# = stat(sleep = 1.0 / LinuxStat::Sysconf.sc_clk_tck)
+			# = stat(sleep = 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5)
 			#
 			# Where sleep is the delay to gather the data.
 			#
@@ -18,7 +18,7 @@ module LinuxStat
 			#    {0=>84.38, 1=>100.0, 2=>50.0, 3=>87.5, 4=>87.5}
 			#
 			# If the information is not available, it will return an empty Hash
-			def stat(sleep = ticks_to_ms)
+			def stat(sleep = ticks_to_ms_t5)
 				return {} unless stat?
 
 				data = IO.readlines('/proc/stat').select! { |x| x[/^cpu\d*/] }.map! { |x| x.split.map!(&:to_f) }
@@ -60,7 +60,7 @@ module LinuxStat
 			# It's like running LinuxStat::CPU.stat[0] but it's much more efficient and calculates just the aggregated usage which is available at the top of the /proc/stat file.
 			#
 			# If the information is not available, it will return nil.
-			def total_usage(sleep = ticks_to_ms)
+			def total_usage(sleep = ticks_to_ms_t5)
 				return nil unless stat?
 
 				data = IO.foreach('/proc/stat').first.split.tap(&:shift).map!(&:to_f)
@@ -136,8 +136,11 @@ module LinuxStat
 				@@stat_readable ||= File.readable?('/proc/stat')
 			end
 
-			def ticks_to_ms
-				@@ms ||= 1.0 / LinuxStat::Sysconf.sc_clk_tck
+			# Just to avoid duplicate calculations
+			# ticks to ms times 5
+			# If the ticks is 100, it will return 0.05
+			def ticks_to_ms_t5
+				@@ms_t5 ||= 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5
 			end
 		end
 	end

data/lib/linux_stat/os.rb

@@ -135,8 +135,8 @@ module LinuxStat
 					key = splitted[0].to_s.strip
 					value = splitted[1..-1].join(?=).to_s.strip
 
-					value[0] = '' if value[0] == ?"
-					value[-1] = '' if value[-1] == ?"
+					value[0] = ''.freeze if value[0] == ?".freeze
+					value[-1] = ''.freeze if value[-1] == ?".freeze
 
 					h.merge!( key.to_sym => value )
 				}

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_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,7 +244,7 @@ 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)
 
@@ -277,15 +277,15 @@ module LinuxStat
 			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:
 			#
@@ -298,7 +298,7 @@ module LinuxStat
 			# 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"
 				return nil unless File.readable?(file)
 
@@ -324,6 +324,54 @@ module LinuxStat
 				totald.-(idle2 - idle1).fdiv(totald).*(100).round(2).abs./(LinuxStat::CPU.count)
 			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"
+				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
+			end
+
 			##
 			# = threads(pid = $$)
 			#
@@ -345,7 +393,7 @@ module LinuxStat
 				file = "/proc/#{pid}/stat".freeze
 				return nil unless File.readable?(file)
 
-				data = IO.read(file).split[19]
+				data = IO.foreach(file, ' '.freeze).first(20)[-1]
 				data ? data.to_i : nil
 			end
 
@@ -383,7 +431,7 @@ module LinuxStat
 				file = "/proc/#{pid}/status".freeze
 				return nil unless File.readable?(file)
 
-				data = IO.readlines(file.freeze).find { |x|
+				data = IO.foreach(file.freeze).find { |x|
 					x[/Uid.*\d*/]
 				}.to_s.split.drop(1)
 
@@ -402,12 +450,12 @@ module LinuxStat
 			#
 			#    :real, :effective, :saved_set, :filesystem_uid
 			#
-			# If the info isn't available it returns an empty Hash.
+			# If the info isn't available or the argument passed doesn't exist as a process ID, it will return an empty Hash.
 			def gid(pid = $$)
 				file = "/proc/#{pid}/status".freeze
 				return nil unless File.readable?(file)
 
-				data = IO.readlines(file.freeze).find { |x|
+				data = IO.foreach(file.freeze).find { |x|
 					x[/Gid.*\d*/]
 				}.split.drop(1)
 
@@ -428,21 +476,132 @@ module LinuxStat
 				file = "/proc/#{pid}/status".freeze
 				return ''.freeze unless File.readable?(file)
 
-				gid = IO.readlines(file.freeze).find { |x|
+				gid = IO.foreach(file.freeze).find { |x|
 					x[/Gid.*\d*/]
 				}.split.drop(1)[2].to_i
 
 				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 = $$)
+			#
+			# Returns the time (as Time object) the process was started.
+			#
+			# For example:
+			#    LinuxStat::ProcessInfo.start_time 14183
+			#
+			#    => 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.
+			#
+			# The timezone returned based on current TZ.
+			# Thus the timezone could be affected by changing the ENV['TZ'] variable.
+			#
+			# Don't trust the timezone returned by the time.
+			def start_time(pid = $$)
+				# 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
+
+			##
+			# = running_time(pid = $$)
+			#
+			# Returns the time (in seconds, as Float) the process is running for.
+			#
+			# For example:
+			#    LinuxStat::ProcessInfo.running_time 14183
+			#
+			#    => 1947.619999999999
+			#
+			# 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 = $$)
+				stat_file = "/proc/#{pid}/stat".freeze
+				uptime = "/proc/uptime".freeze
+
+				@@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)
+			end
+
+			##
+			# = state(pid = $$)
+			# Returns the state of the process as a frozen String
+			#
+			# * A process could have multiple states:
+			#
+			# 1. S => Sleeping
+			#
+			# 2. R => Running
+			#
+			# 3. I => Idle
+			#
+			# 4. Z => Zombie
+			#
+			# It returns any one of them.
+			#
+			# If the info isn't available or the argument passed doesn't exist as a process ID,
+			# it will return an empty String.
+			def state(pid = $$)
+				file = "/proc/#{pid}/stat".freeze
+				return ''.freeze unless File.readable?(file)
+				IO.foreach(file, ' '.freeze).first(3)[-1].tap(&:rstrip!).freeze
+			end
+
+			##
+			# = nice(pid = $$)
+			# Returns the nice of the process
+			#
+			# The output value is an Integer ranging from -20 to 19
+			#
+			# -20 means the process has high priority, and 19 means the process has low priority
+			#
+			# If the info isn't available or the argument passed doesn't exist as a process ID, it will return nil.
+			def nice(pid = $$)
+				file = "/proc/#{pid}/stat"
+				return nil unless File.readable?(file)
+
+				IO.foreach(file, ' ').first(19)[-1].to_i
+			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
+			# 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